43 #ifndef IFPACK_SPARSECONTAINER_H
44 #define IFPACK_SPARSECONTAINER_H
46 #include "Ifpack_Container.h"
47 #include "Epetra_IntSerialDenseVector.h"
48 #include "Epetra_MultiVector.h"
49 #include "Epetra_Vector.h"
50 #include "Epetra_Map.h"
51 #include "Epetra_RowMatrix.h"
52 #include "Epetra_CrsMatrix.h"
53 #include "Epetra_LinearProblem.h"
54 #include "Epetra_IntSerialDenseVector.h"
55 #include "Teuchos_ParameterList.hpp"
56 #include "Teuchos_RefCountPtr.hpp"
58 #include "Epetra_MpiComm.h"
60 #include "Epetra_SerialComm.h"
127 if (NumVectors_ != NumVectors_in)
129 NumVectors_=NumVectors_in;
137 virtual double&
LHS(
const int i,
const int Vector = 0);
140 virtual double&
RHS(
const int i,
const int Vector = 0);
152 virtual int&
ID(
const int i);
162 return(IsInitialized_);
177 return(Label_.c_str());
181 Teuchos::RCP<const Epetra_Map>
Map()
const
187 Teuchos::RCP<const Epetra_MultiVector>
LHS()
const
193 Teuchos::RCP<const Epetra_MultiVector>
RHS()
const
199 Teuchos::RCP<const Epetra_CrsMatrix>
Matrix()
const
244 if (Inverse_ == Teuchos::null)
247 return(Inverse_->InitializeFlops());
253 if (Inverse_ == Teuchos::null)
256 return(Inverse_->ComputeFlops());
268 if (Inverse_ == Teuchos::null)
271 return(Inverse_->ApplyInverseFlops());
275 virtual std::ostream&
Print(std::ostream& os)
const;
287 Teuchos::RefCountPtr<Epetra_Map> Map_;
289 Teuchos::RefCountPtr<Epetra_CrsMatrix> Matrix_;
291 Teuchos::RefCountPtr<Epetra_MultiVector> LHS_;
293 Teuchos::RefCountPtr<Epetra_MultiVector> RHS_;
301 Teuchos::RefCountPtr<Epetra_Comm> SerialComm_;
303 Teuchos::RefCountPtr<T> Inverse_;
306 Teuchos::ParameterList List_;
315 NumRows_(NumRows_in),
316 NumVectors_(NumVectors_in),
317 IsInitialized_(false),
334 NumRows_(rhs.NumRows()),
335 NumVectors_(rhs.NumVectors()),
336 IsInitialized_(rhs.IsInitialized()),
337 IsComputed_(rhs.IsComputed())
346 if (!rhs.
Map().is_null())
349 if (!rhs.
Matrix().is_null())
352 if (!rhs.
LHS().is_null())
355 if (!rhs.
RHS().is_null())
370 if (IsInitialized() ==
false)
381 if (IsInitialized_ ==
true)
384 IsInitialized_ =
false;
386 #if !defined(EPETRA_NO_32BIT_GLOBAL_INDICES) || !defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
387 Map_ = Teuchos::rcp(
new Epetra_Map(NumRows_,0,*SerialComm_) );
392 GID_.Reshape(NumRows_,1);
394 #if defined(HAVE_TEUCHOSCORE_CXX11)
395 Matrix_ = Teuchos::rcp(
new Epetra_CrsMatrix(Epetra_DataAccess::Copy,*Map_,0) );
401 Inverse_ = Teuchos::rcp(
new T(Matrix_.get()) );
403 if (Inverse_ == Teuchos::null)
406 IFPACK_CHK_ERR(Inverse_->SetParameters(List_));
412 Label_ =
"Ifpack_SparseContainer";
414 IsInitialized_ =
true;
423 return(((*LHS_)(Vector))->Values()[i]);
430 return(((*RHS_)(Vector))->Values()[i]);
438 if (!IsInitialized())
441 if ((row < 0) || (row >= NumRows())) {
445 if ((col < 0) || (col >= NumRows())) {
449 #ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
450 if(Matrix_->RowMatrixRowMap().GlobalIndicesInt()) {
451 int ierr = Matrix_->InsertGlobalValues((
int)row,1,(
double*)&value,(
int*)&col);
453 ierr = Matrix_->SumIntoGlobalValues((
int)row,1,(
double*)&value,(
int*)&col);
460 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
461 if(Matrix_->RowMatrixRowMap().GlobalIndicesLongLong()) {
462 long long col_LL = col;
463 int ierr = Matrix_->InsertGlobalValues(row,1,(
double*)&value,&col_LL);
465 ierr = Matrix_->SumIntoGlobalValues(row,1,(
double*)&value,&col_LL);
472 throw "Ifpack_SparseContainer<T>::SetMatrixElement: GlobalIndices type unknown";
484 if (!IsInitialized()) {
485 IFPACK_CHK_ERR(Initialize());
489 IFPACK_CHK_ERR(Extract(Matrix_in));
492 IFPACK_CHK_ERR(Inverse_->Initialize());
495 IFPACK_CHK_ERR(Inverse_->Compute());
497 Label_ =
"Ifpack_SparseContainer";
508 if (IsComputed() ==
false) {
512 IFPACK_CHK_ERR(Matrix_->Apply(*RHS_, *LHS_));
514 ApplyFlops_ += 2 * Matrix_->NumGlobalNonzeros64();
525 IFPACK_CHK_ERR(Inverse_->ApplyInverse(*RHS_, *LHS_));
535 IsInitialized_ =
false;
562 for (
int j = 0 ; j < NumRows_ ; ++j) {
572 std::vector<double> Values;
573 Values.resize(Length);
574 std::vector<int> Indices;
575 Indices.resize(Length);
577 for (
int j = 0 ; j < NumRows_ ; ++j) {
585 &Values[0], &Indices[0]);
586 IFPACK_CHK_ERR(ierr);
588 for (
int k = 0 ; k < NumEntries ; ++k) {
590 int LCID = Indices[k];
600 for (
int kk = 0 ; kk < NumRows_ ; ++kk)
605 SetMatrixElement(j,jj,Values[k]);
610 IFPACK_CHK_ERR(Matrix_->FillComplete());
621 os <<
"================================================================================" << endl;
622 os <<
"Ifpack_SparseContainer" << endl;
623 os <<
"Number of rows = " << NumRows() << endl;
624 os <<
"Number of vectors = " << NumVectors() << endl;
625 os <<
"IsInitialized() = " << IsInitialized() << endl;
626 os <<
"IsComputed() = " << IsComputed() << endl;
627 os <<
"Flops in Initialize() = " << InitializeFlops() << endl;
628 os <<
"Flops in Compute() = " << ComputeFlops() << endl;
629 os <<
"Flops in ApplyInverse() = " << ApplyInverseFlops() << endl;
630 os <<
"================================================================================" << endl;
635 #endif // IFPACK_SPARSECONTAINER_H
virtual double ComputeFlops() const
Returns the flops in Compute().
virtual double InitializeFlops() const
Returns the flops in Compute().
Teuchos::RCP< const Epetra_MultiVector > LHS() const
Returns a pointer to the internally stored solution multi-vector.
virtual int NumRows() const
Returns the number of rows of the matrix and LHS/RHS.
Ifpack_SparseContainer & operator=(const Ifpack_SparseContainer< T > &rhs)
Operator =.
Teuchos::RCP< const Epetra_MultiVector > RHS() const
Returns a pointer to the internally stored rhs multi-vector.
virtual int SetParameters(Teuchos::ParameterList &List)
Sets all necessary parameters.
virtual bool IsInitialized() const
Returns true is the container has been successfully initialized.
Teuchos::RCP< const Epetra_CrsMatrix > Matrix() const
Returns a pointer to the internally stored matrix.
virtual double & LHS(const int i, const int Vector=0)
Returns the i-th component of the vector Vector of LHS.
virtual int Initialize()
Initializes the container, by completing all the operations based on matrix structure.
virtual int SetMatrixElement(const int row, const int col, const double value)
Set the matrix element (row,col) to value.
virtual const char * Label() const
Returns the label of this container.
virtual double & RHS(const int i, const int Vector=0)
Returns the i-th component of the vector Vector of RHS.
Teuchos::RCP< const Epetra_Map > Map() const
Returns a pointer to the internally stored map.
virtual int MaxNumEntries() const =0
virtual int NumVectors() const
Returns the number of vectors in LHS/RHS.
Ifpack_SparseContainer: a class for storing and solving linear systems using sparse matrices...
virtual int SetNumVectors(const int NumVectors_in)
Sets the number of vectors for LHS/RHS.
virtual int ApplyInverse()
Apply the inverse of the matrix to RHS, result is stored in LHS.
Ifpack_SparseContainer(const int NumRows, const int NumVectors=1)
Constructor.
virtual int NumMyRows() const =0
virtual double ApplyFlops() const
Returns the flops in Apply().
virtual std::ostream & Print(std::ostream &os) const
Prints basic information on iostream. This function is used by operator<<.
virtual ~Ifpack_SparseContainer()
Destructor.
Teuchos::RCP< const T > Inverse() const
Returns a pointer to the internally stored inverse operator.
const Epetra_IntSerialDenseVector & ID() const
Returns a pointer to the internally stored ID's.
virtual int Destroy()
Destroys all data.
Ifpack_Container: a pure virtual class for creating and solving local linear problems.
virtual int ExtractMyRowCopy(int MyRow, int Length, int &NumEntries, double *Values, int *Indices) const =0
virtual bool IsComputed() const
Returns true is the container has been successfully computed.
virtual int Compute(const Epetra_RowMatrix &Matrix_in)
Finalizes the linear system matrix and prepares for the application of the inverse.
virtual double ApplyInverseFlops() const
Returns the flops in ApplyInverse().
virtual int Apply()
Apply the matrix to RHS, result is stored in LHS.