EpetraExt_PETScAIJMatrix.h

Go to the documentation of this file.

//@HEADER
// ***********************************************************************
// 
//     EpetraExt: Epetra Extended - Linear Algebra Services Package
//                 Copyright (2001) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
//@HEADER

/*#############################################################################
# CVS File Information
#    Current revision: $Revision$
#    Last modified:    $Date$
#    Modified by:      $Author$
#############################################################################*/

#ifndef _EPETRAEXT_PETSCAIJMATRIX_H_
#define _EPETRAEXT_PETSCAIJMATRIX_H_

#include "Epetra_Object.h"
#include "Epetra_CompObject.h"
#include "Epetra_RowMatrix.h"
#include "Epetra_Map.h"
#ifdef HAVE_MPI
#include "Epetra_MpiComm.h"
#else
#include "Epetra_SerialComm.h"
#endif
extern "C" {
//Petsc headers.
//Note: Petsc internally hard-codes paths to headers, relative to the PETSC home
//      directory.  This means that --with-incdirs must contain the full path(s)
//      to the header below plus the PETSc home directory.
#include "src/mat/impls/aij/mpi/mpiaij.h"
}

class Epetra_Import;
class Epetra_Export;
class Epetra_Vector;
class Epetra_MultiVector;


class Epetra_PETScAIJMatrix: public Epetra_Object, public Epetra_CompObject, public virtual Epetra_RowMatrix  {
      
 public:




  Epetra_PETScAIJMatrix(Mat Amat);

  virtual ~Epetra_PETScAIJMatrix();
  



    int ExtractMyRowCopy(int MyRow, int Length, int & NumEntries, double *Values, int * Indices) const;


    int ExtractDiagonalCopy(Epetra_Vector & Diagonal) const;




    int Multiply(bool TransA, const Epetra_MultiVector& X, Epetra_MultiVector& Y) const;


    int Solve(bool Upper, bool Trans, bool UnitDiagonal, const Epetra_MultiVector& X, Epetra_MultiVector& Y) const;


    int InvRowSums(Epetra_Vector& x) const;


    int LeftScale(const Epetra_Vector& x);


    int InvColSums(Epetra_Vector& x) const;


    int RightScale(const Epetra_Vector& x);




    bool Filled() const {return(true);};

    bool LowerTriangular() const {return(false);};

    bool UpperTriangular() const {return(false);};

  


    Mat Amat() const {return(Amat_);};

    /* Returns the quantity \f$ \| A \|_\infty\f$ such that
       \f[\| A \|_\infty = \max_{1\lei\lem} \sum_{j=1}^n |a_{ij}| \f].
    */ 
    double NormInf() const;

    /* Returns the quantity \f$ \| A \|_1\f$ such that
       \f[\| A \|_1= \max_{1\lej\len} \sum_{i=1}^m |a_{ij}| \f].
    */ 
    double NormOne() const;

    int NumGlobalNonzeros() const {return(NumGlobalNonzeros_);};

    int NumGlobalRows() const {return(OperatorRangeMap().NumGlobalPoints());};

    int NumGlobalCols() const {return(OperatorDomainMap().NumGlobalPoints());};

    int NumGlobalDiagonals() const{return(OperatorDomainMap().NumGlobalPoints());};
    
    int NumMyNonzeros() const {return(NumMyNonzeros_);};

    int NumMyRows() const {return(OperatorRangeMap().NumMyPoints());};

    int NumMyCols() const {return(RowMatrixColMap().NumMyPoints());};

    int NumMyDiagonals() const {return(OperatorRangeMap().NumMyPoints());};

    const Epetra_Map & OperatorDomainMap() const {return(*DomainMap_);};

    const Epetra_Map & OperatorRangeMap() const  {return(*DomainMap_);};

    const Epetra_BlockMap& Map() const {return(RowMatrixRowMap());}

    const Epetra_Map & RowMatrixRowMap() const {return(OperatorRangeMap());};

    const Epetra_Map & RowMatrixColMap() const {return(*ColMap_);};

    virtual const Epetra_Import * RowMatrixImporter() const {return(Importer_);};

    const Epetra_Comm & Comm() const {return(*Comm_);};
  
  


  virtual void Print(ostream & os) const;



    const char * Label() const {return(Epetra_Object::Label());};
    

  int SetUseTranspose(bool UseTranspose)
    {(void)UseTranspose; return(-1);}


  int Apply(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const {
    return(Epetra_PETScAIJMatrix::Multiply(Epetra_PETScAIJMatrix::UseTranspose(), X, Y));};


  int ApplyInverse(const Epetra_MultiVector& X,
                   Epetra_MultiVector& Y) const
    {(void)X; (void)Y; return(-1);}

    virtual bool HasNormInf() const {return(true);}

    virtual bool UseTranspose() const {return(false);}





    int NumMyRowEntries(int MyRow, int & NumEntries) const;

    int MaxNumEntries() const;

 private:

    int GetRow(int Row) const;
    Mat Amat_;                //general PETSc matrix type
    mutable double * Values_;
    mutable int * Indices_;
    mutable int MaxNumEntries_;
    
#ifdef HAVE_MPI
    Epetra_MpiComm * Comm_;
#else
    Epetra_SerialComm * Comm_;
#endif  
    Epetra_Map * DomainMap_;
    Epetra_Map * ColMap_;
    Epetra_Import * Importer_;
    mutable Epetra_MultiVector * ImportVector_;
 
    double NumGlobalNonzeros_;
    int NumMyNonzeros_;
    int NumMyRows_;
    int NumGlobalRows_;
    int NumMyCols_;
    int PetscRowStart_;
    int PetscRowEnd_;
    enum petscMatrixType {PETSC_SEQ_AIJ, PETSC_MPI_AIJ};
    const MatType MatType_;         //really const char*
    mutable double NormInf_;
    mutable double NormOne_;

    
  //FIXME we need a copy ctor
  //Epetra_PETScAIJMatrix(const Epetra_PETScAIJMatrix & Matrix) {(void)Matrix;}
};
#endif /* _EPETRAEXT_PETSCAIJMATRIX_H_ */