Ifpack_DenseContainer.h

#ifndef IFPACK_DENSECONTAINER_H
#define IFPACK_DENSECONTAINER_H

#include "Ifpack_ConfigDefs.h"
#include "Ifpack_Container.h"
#include "Epetra_SerialDenseMatrix.h"
#include "Epetra_SerialDenseSolver.h"
#include "Epetra_IntSerialDenseVector.h"
class Epetra_RowMatrix;


class Ifpack_DenseContainer : public Ifpack_Container {

public:


  Ifpack_DenseContainer(const int NumRows, const int NumVectors = 1) :
    NumRows_(NumRows),
    NumVectors_(NumVectors),
    KeepNonFactoredMatrix_(false),
    IsInitialized_(false),
    IsComputed_(false),
    ComputeFlops_(0.0),
    ApplyFlops_(0.0),
    ApplyInverseFlops_(0.0)
  {}

  Ifpack_DenseContainer(const Ifpack_DenseContainer& rhs) :
    NumRows_(rhs.NumRows()),
    NumVectors_(rhs.NumVectors()),
    KeepNonFactoredMatrix_(rhs.KeepNonFactoredMatrix()),
    IsInitialized_(rhs.IsInitialized()),
    IsComputed_(rhs.IsComputed())
  {
    Matrix_ = rhs.Matrix();
    if (KeepNonFactoredMatrix_)
      NonFactoredMatrix_ = rhs.NonFactoredMatrix();
    LHS_ = rhs.LHS();
    RHS_ = rhs.RHS();
    ID_ = rhs.ID();
  }
    
  virtual ~Ifpack_DenseContainer()
  {}


  Ifpack_DenseContainer& operator=(const Ifpack_DenseContainer& rhs)
  {
    if (&rhs == this)
      return(*this);

    NumRows_ = rhs.NumRows();
    NumVectors_ = rhs.NumVectors();
    IsComputed_ = rhs.IsComputed();
    KeepNonFactoredMatrix_ = rhs.KeepNonFactoredMatrix();
    Matrix_ = rhs.Matrix();
    if (KeepNonFactoredMatrix_)
      NonFactoredMatrix_ = rhs.NonFactoredMatrix();
    LHS_ = rhs.LHS();
    RHS_ = rhs.RHS();
    ID_ = rhs.ID();

    return(*this);
  }



  virtual int NumRows() const;

  virtual int NumVectors() const
  {
    return(NumVectors_);
  }

  virtual int SetNumVectors(const int NumVectors)
  {
    if (NumVectors_ == NumVectors) 
      return(0);

    NumVectors_ = NumVectors;
    IFPACK_CHK_ERR(RHS_.Reshape(NumRows_,NumVectors_));
    IFPACK_CHK_ERR(RHS_.Reshape(NumRows_,NumVectors_));
    // zero out vector elements
    for (int i = 0 ; i < NumRows_ ; ++i)
      for (int j = 0 ; j < NumVectors_ ; ++j) {
    LHS_(i,j) = 0.0;
    RHS_(i,j) = 0.0;
      }

    return(0);
  }

  virtual double& LHS(const int i, const int Vector = 0);
  
  virtual double& RHS(const int i, const int Vector = 0);


  virtual int& ID(const int i);

  virtual int SetMatrixElement(const int row, const int col,
                   const double value);

  virtual int SetParameters(Teuchos::ParameterList& List)
  {
    return(0);
  }

  virtual bool IsInitialized() const
  {
    return(IsInitialized_);
  }

  virtual bool IsComputed() const
  {
    return(IsComputed_);
  }

  virtual const char* Label() const
  {
    return(Label_.c_str());
  }

  virtual int SetKeepNonFactoredMatrix(const bool flag)
  {
    KeepNonFactoredMatrix_ = flag;
    return(0);
  }

  virtual bool KeepNonFactoredMatrix() const
  {
    return(KeepNonFactoredMatrix_);
  }

  virtual const Epetra_SerialDenseMatrix& LHS() const
  {
    return(LHS_);
  }

  virtual const Epetra_SerialDenseMatrix& RHS() const
  {
    return(RHS_);
  }

  virtual const Epetra_SerialDenseMatrix& Matrix() const
  {
    return(Matrix_);
  }

  virtual const Epetra_SerialDenseMatrix& NonFactoredMatrix() const
  {
    return(NonFactoredMatrix_);
  }

  virtual const Epetra_IntSerialDenseVector& ID() const
  {
    return(ID_);
  }



  virtual int Initialize();

  virtual int Compute(const Epetra_RowMatrix& Matrix);

  virtual int Apply();

  virtual int ApplyInverse();


  virtual double InitializeFlops() const
  {
    return(0.0);
  }

  virtual double ComputeFlops() const
  {
    return(ComputeFlops_);
  }

  virtual double ApplyFlops() const
  {
    return(ApplyFlops_);
  }

  virtual double ApplyInverseFlops() const
  {
    return(ApplyInverseFlops_);
  }

  virtual ostream& Print(std::ostream& os) const;

private:
  
  virtual int Extract(const Epetra_RowMatrix& Matrix);

  int NumRows_; 
  int NumVectors_;
  Epetra_SerialDenseMatrix NonFactoredMatrix_;
  Epetra_SerialDenseMatrix Matrix_;
  Epetra_SerialDenseMatrix LHS_;
  Epetra_SerialDenseMatrix RHS_;
  Epetra_SerialDenseSolver Solver_;
  Epetra_IntSerialDenseVector ID_;
  bool KeepNonFactoredMatrix_;
  bool IsInitialized_;
  bool IsComputed_;
  string Label_;

  double ComputeFlops_;
  double ApplyFlops_;
  double ApplyInverseFlops_;
};

#endif

---