Actual source code: matrix.h

  1: #ifndef __PETSc_Matrix_h__

  4: // this contains the PETSc definition of Matrix
 5:  #include petscmat.h

 7:  #include esi/petsc/vector.h

  9: // The esi::petsc::Matrix supports the
 10: #include "esi/Operator.h"
 11: #include "esi/MatrixData.h"
 12: #include "esi/MatrixRowReadAccess.h"
 13: #include "esi/MatrixRowWriteAccess.h"

 15: namespace esi{namespace petsc{

 17: /**=========================================================================**/
 18: template<class Scalar,class Ordinal>
 19: class Matrix : public virtual esi::Operator<Scalar,Ordinal>,
 20:                public virtual esi::MatrixData<Ordinal>,
 21:                public virtual esi::MatrixRowReadAccess<Scalar,Ordinal>,
 22:                public virtual esi::MatrixRowWriteAccess<Scalar,Ordinal>,
 23:                public         esi::petsc::Object
 24: {
 25:   public:

 27:     // Default destructor.
 28:     ~Matrix();

 30:     // Construct a matrix from two IndexSpaces.
 31:     Matrix(esi::IndexSpace<Ordinal> *rsource,esi::IndexSpace<Ordinal> *csource);

 33:     // Construct a esi::petsc::matrix from a PETSc Mat
 34:     Matrix(Mat pmat);

 36:     //  Interface for esi::Object  ---------------

 38:     virtual esi::ErrorCode getInterface(const char* name, void*& iface) ;
 39:     virtual esi::ErrorCode getInterfacesSupported(esi::Argv * list);


 42:     //  Interface for esi::Operator  ---------------

 44:     virtual esi::ErrorCode setup();
 45:     virtual esi::ErrorCode apply( esi::Vector<Scalar,Ordinal>& x, esi::Vector<Scalar,Ordinal>& y);

 47:     //  Interface for esi::MatrixData  ---------------
 48:     virtual esi::ErrorCode getGlobalSizes(Ordinal& rows, Ordinal& columns);
 49:     virtual esi::ErrorCode getLocalSizes(Ordinal& rows, Ordinal& columns);

 51:     //  Interface for esi::MatrixRowAccess  --------

 53:     virtual esi::ErrorCode getIndexSpaces(esi::IndexSpace<Ordinal>*& rowIndexSpace, esi::IndexSpace<Ordinal>*& colIndexSpace);
 54:     virtual esi::ErrorCode isLoaded(bool &state);
 55:     virtual esi::ErrorCode isAllocated(bool &state);
 56:     virtual esi::ErrorCode loadComplete(void);
 57:     virtual esi::ErrorCode allocate(Ordinal *rowLengths);
 58:     virtual esi::ErrorCode getDiagonal(esi::Vector<Scalar,Ordinal>& diagVector) ;
 59:     virtual esi::ErrorCode getRowSum(esi::Vector<Scalar,Ordinal>& rowSumVector) ;
 60:     virtual esi::ErrorCode getRowNonzeros(Ordinal row, Ordinal& length);
 61:     virtual esi::ErrorCode setRowLength(Ordinal row,Ordinal length);
 62:     virtual esi::ErrorCode getRow(Ordinal row, Ordinal& length, Scalar*& coefs, Ordinal*& colIndices) ;
 63:     virtual esi::ErrorCode getRowCoefs(Ordinal row, Ordinal& length, Scalar*& coefs) ;
 64:     virtual esi::ErrorCode getRowIndices(Ordinal row, Ordinal& length, Ordinal*& colIndices) ;
 65:     virtual esi::ErrorCode restoreRow(Ordinal row, Ordinal& length, Scalar*& coefs, Ordinal*& colIndices) ;
 66:     virtual esi::ErrorCode restoreRowCoefs(Ordinal row, Ordinal& length, Scalar*& coefs) ;
 67:     virtual esi::ErrorCode restoreRowIndices(Ordinal row, Ordinal& length, Ordinal*& colIndices) ;
 68:     virtual esi::ErrorCode copyIntoRow(Ordinal row,  Scalar* coefs, Ordinal* colIndices, Ordinal length);
 69:     virtual esi::ErrorCode sumIntoRow(Ordinal row,  Scalar* coefs, Ordinal* colIndices, Ordinal length);
 70:     virtual esi::ErrorCode rowMax(Ordinal row, Scalar& result) ;
 71:     virtual esi::ErrorCode rowMin(Ordinal row, Scalar& result) ;

 73:     virtual esi::ErrorCode getRowAllocatedLength(Ordinal row, int& result) {return 1;};
 74:     virtual esi::ErrorCode setAllValues(Scalar) {return 1;};
 75:     virtual esi::ErrorCode allocateRowsSameLength(Ordinal) {return 1;};
 76:     virtual esi::ErrorCode copyOutRow(Ordinal, Scalar *,int *,int,int&) ;
 77:     virtual esi::ErrorCode copyOutRowIndices(Ordinal, int *,int,int&) {return 1;};
 78:     virtual esi::ErrorCode copyOutRowCoefficients(Ordinal, Scalar *,int,int&) {return 1;};

 80:   private:
 81:     Mat                        mat;
 82:     esi::IndexSpace<Ordinal> *rmap,*cmap;
 83: };

 85: /**=========================================================================**/
 86: template<>
 87: class Matrix<double,int> : public virtual esi::Operator<double,int>,
 88:                public virtual esi::MatrixData<int>,
 89:                public virtual esi::MatrixRowReadAccess<double,int>,
 90:                public virtual esi::MatrixRowWriteAccess<double,int>,
 91:                public         esi::petsc::Object
 92: {
 93:   public:

 95:     // Default destructor.
 96:     ~Matrix();

 98:     // Construct a matrix from two IndexSpaces.
 99:     Matrix(esi::IndexSpace<int> *rsource,esi::IndexSpace<int> *csource);

101:     // Construct a esi::petsc::matrix from a PETSc Mat
102:     Matrix(Mat pmat);

104:     //  Interface for esi::Object  ---------------

106:     virtual esi::ErrorCode getInterface(const char* name, void*& iface) ;
107:     virtual esi::ErrorCode getInterfacesSupported(esi::Argv * list);


110:     //  Interface for esi::Operator  ---------------

112:     virtual esi::ErrorCode setup();
113:     virtual esi::ErrorCode apply( esi::Vector<double,int>& x, esi::Vector<double,int>& y);

115:     //  Interface for esi::MatrixData  ---------------
116:     virtual esi::ErrorCode getGlobalSizes(int& rows, int& columns);
117:     virtual esi::ErrorCode getLocalSizes(int& rows, int& columns);

119:     //  Interface for esi::MatrixRowAccess  --------

121:     virtual esi::ErrorCode getIndexSpaces(esi::IndexSpace<int>*& rowIndexSpace, esi::IndexSpace<int>*& colIndexSpace);
122:     virtual esi::ErrorCode isLoaded(bool &state);
123:     virtual esi::ErrorCode isAllocated(bool &state);
124:     virtual esi::ErrorCode loadComplete(void);
125:     virtual esi::ErrorCode allocate(int *rowLengths);
126:     virtual esi::ErrorCode getDiagonal(esi::Vector<double,int>& diagVector) ;
127:     virtual esi::ErrorCode getRowSum(esi::Vector<double,int>& rowSumVector) ;
128:     virtual esi::ErrorCode getRowNonzeros(int row, int& length);
129:     virtual esi::ErrorCode setRowLength(int row,int length);
130:     virtual esi::ErrorCode getRow(int row, int& length, double*& coefs, int*& colIndices) ;
131:     virtual esi::ErrorCode getRowCoefs(int row, int& length, double*& coefs) ;
132:     virtual esi::ErrorCode getRowIndices(int row, int& length, int*& colIndices) ;
133:     virtual esi::ErrorCode restoreRow(int row, int& length, double*& coefs, int*& colIndices) ;
134:     virtual esi::ErrorCode restoreRowCoefs(int row, int& length, double*& coefs) ;
135:     virtual esi::ErrorCode restoreRowIndices(int row, int& length, int*& colIndices) ;
136:     virtual esi::ErrorCode copyIntoRow(int row,  double* coefs, int* colIndices, int length);
137:     virtual esi::ErrorCode sumIntoRow(int row,  double* coefs, int* colIndices, int length);
138:     virtual esi::ErrorCode rowMax(int row, double& result) ;
139:     virtual esi::ErrorCode rowMin(int row, double& result) ;

141:     virtual esi::ErrorCode getRowAllocatedLength(int row, int& result) {return 1;};
142:     virtual esi::ErrorCode setAllValues(double) {return 1;};
143:     virtual esi::ErrorCode allocateRowsSameLength(int) {return 1;};
144:     virtual esi::ErrorCode copyOutRow(int, double *,int *,int,int&) ;
145:     virtual esi::ErrorCode copyOutRowIndices(int, int *,int,int&) {return 1;};
146:     virtual esi::ErrorCode copyOutRowCoefficients(int, double *,int,int&) {return 1;};

148:   private:
149:     Mat                        mat;
150:     esi::IndexSpace<int> *rmap,*cmap;
151: };

153: }

155:   /* -------------------------------------------------------------------------*/

157: template<class Scalar,class Ordinal> class OperatorFactory
158: #if defined(PETSC_HAVE_CCA)
159:            :  public virtual gov::cca::Port, public virtual gov::cca::Component
160: #endif
161: {
162:   public:

164:     // Destructor.
165:   virtual ~OperatorFactory(void){};

167:     // Interface for gov::cca::Component
168: #if defined(PETSC_HAVE_CCA)
169:     virtual void setServices(gov::cca::Services *) = 0;
170: #endif

172:     // Construct a Operator
173:     virtual esi::ErrorCode getOperator(esi::IndexSpace<Ordinal>&,esi::IndexSpace<Ordinal>&,esi::Operator<Scalar,Ordinal>*&v) = 0;
174: };

176: }


179: #endif