fei_LinearSystemCore.hpp

#ifndef _fei_LinearSystemCore_hpp_
#define _fei_LinearSystemCore_hpp_

class Data;
class Lookup;

#include <fei_defs.h>
#include <cstdlib>

class LinearSystemCore {
 public:
   LinearSystemCore(){};

   virtual ~LinearSystemCore() {};


   virtual LinearSystemCore* clone() = 0;


   virtual int parameters(int numParams, const char*const * params) = 0;


   virtual int setLookup(Lookup& lookup) = 0;


   virtual int getProperty(const char* /*name*/, double& /*value*/)
     {
       return(-1);
     }

   virtual int setGlobalOffsets(int len, int* nodeOffsets,
                                 int* eqnOffsets, int* blkEqnOffsets) = 0;


   virtual int setConnectivities(GlobalID elemBlock,
                                  int numElements,
                                  int numNodesPerElem,
                                  const GlobalID* elemIDs,
                                  const int* const* connNodes) = 0;


   virtual int setStiffnessMatrices(GlobalID elemBlock,
                                     int numElems,
                                     const GlobalID* elemIDs,
                                     const double *const *const *stiff,
                                     int numEqnsPerElem,
                                     const int *const * eqnIndices) = 0;


   virtual int setLoadVectors(GlobalID elemBlock,
                               int numElems,
                               const GlobalID* elemIDs,
                               const double *const * load,
                               int numEqnsPerElem,
                               const int *const * eqnIndices) = 0;


   virtual int setMatrixStructure(int** ptColIndices,
                                   int* ptRrowLengths,
                                   int** blkColIndices,
                                   int* blkRowLengths,
                                   int* ptRowsPerBlkRow) = 0;


   virtual int setMultCREqns(int multCRSetID,
                              int numCRs, int numNodesPerCR,
                              int** nodeNumbers, int** eqnNumbers,
                              int* fieldIDs,
                              int* multiplierEqnNumbers) = 0;

   virtual int setPenCREqns(int penCRSetID,
                              int numCRs, int numNodesPerCR,
                              int** nodeNumbers, int** eqnNumbers,
                              int* fieldIDs) = 0;


   virtual int sumIntoSystemMatrix(int numPtRows, const int* ptRows,
                                    int numPtCols, const int* ptCols,
                                    int numBlkRows, const int* blkRows,
                                    int numBlkCols, const int* blkCols,
                                    const double* const* values) = 0;

   virtual int sumIntoSystemMatrix(int numPtRows, const int* ptRows,
                                    int numPtCols, const int* ptCols,
                                    const double* const* values) = 0;

   virtual int putIntoSystemMatrix(int numPtRows, const int* ptRows,
                                    int numPtCols, const int* ptCols,
                                    const double* const* values) = 0;

   virtual int getMatrixRowLength(int row, int& length) = 0;

   virtual int getMatrixRow(int row, double* coefs, int* indices,
                            int len, int& rowLength) = 0;

   virtual int sumIntoRHSVector(int num, const double* values,
                                 const int* indices) = 0;
   virtual int putIntoRHSVector(int num, const double* values,
                                 const int* indices) = 0;
   virtual int getFromRHSVector(int num, double* values,
                                 const int* indices) = 0;

   virtual int matrixLoadComplete() = 0;

   virtual int putNodalFieldData(int fieldID, int fieldSize,
                                  int* nodeNumbers, int numNodes,
                                  const double* data) = 0;


   virtual int resetMatrixAndVector(double s) = 0;

   virtual int resetMatrix(double s) = 0;

   virtual int resetRHSVector(double s) = 0;

   virtual int enforceEssentialBC(int* globalEqn, double* alpha,
                                   double* gamma, int len) = 0;

   virtual int enforceRemoteEssBCs(int numEqns, int* globalEqns,
                                          int** colIndices, int* colIndLen,
                                          double** coefs) = 0;

   virtual int getMatrixPtr(Data& data) = 0;

   virtual int copyInMatrix(double scalar, const Data& data) = 0;

   virtual int copyOutMatrix(double scalar, Data& data) = 0;

   virtual int sumInMatrix(double scalar, const Data& data) = 0;

   virtual int getRHSVectorPtr(Data& data) = 0;

   virtual int copyInRHSVector(double scalar, const Data& data) = 0;

   virtual int copyOutRHSVector(double scalar, Data& data) = 0;

   virtual int sumInRHSVector(double scalar, const Data& data) = 0;

   virtual int destroyMatrixData(Data& data) = 0;

   virtual int destroyVectorData(Data& data) = 0;

   virtual int setNumRHSVectors(int numRHSs, const int* rhsIDs) = 0;

   virtual int setRHSID(int rhsID) = 0;

   virtual int putInitialGuess(const int* eqnNumbers, const double* values,
                                int len) = 0;

   virtual int getSolution(double* answers, int len) = 0;

   virtual int getSolnEntry(int eqnNumber, double& answer) = 0;

   virtual int formResidual(double* values, int len) = 0;

   virtual int launchSolver(int& solveStatus, int& iterations) = 0;

   virtual int writeSystem(const char* name) = 0;

   virtual double* getMatrixBeginPointer()
   { return NULL; }

   virtual int getMatrixOffset(int /*row*/, int /*col*/)
   { return -1; }

};

#endif