SPRMatrix.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _SPR_MATRIX_H
#define _SPR_MATRIX_H
 
#include "SystemMatrix.h"
#ifdef USE_INT64
#include <cstdint>
#define Int_ std::int64_t
#else
#define Int_ int
#endif
#define NS 60
 
 
class SPRMatrix : public SystemMatrix
{
public:
  SPRMatrix();
  SPRMatrix(const SPRMatrix& A);
  virtual ~SPRMatrix();
 
  virtual LinAlg::MatrixType getType() const { return LinAlg::SPR; }
 
  virtual SystemMatrix* copy() const { return new SPRMatrix(*this); }
 
  SPRMatrix& operator=(const SPRMatrix&) = delete;
 
  virtual size_t dim(int idim) const;
 
  virtual void initAssembly(const SAM& sam, char);
 
  virtual void init();
 
  using SystemMatrix::assemble;
  virtual bool assemble(const Matrix& eM, const SAM& sam, int e);
  virtual bool assemble(const Matrix& eM, const SAM& sam,
                        SystemVector& B, int e);
  virtual bool assemble(const Matrix& eM, const SAM& sam,
                        SystemVector& B, const IntVec& meq);
 
  virtual bool assemble(const Matrix& eM, const IntVec& meq);
 
  virtual void mult(Real alpha);
 
  virtual bool add(const SystemMatrix& B, Real alpha);
 
  virtual bool add(Real sigma, int ieq);
 
  virtual bool multiply(const SystemVector& B, SystemVector& C) const;
 
  using SystemMatrix::solve;
  virtual bool solve(SystemVector& B, Real*);
 
  bool solveEig(SPRMatrix& B, RealArray& val, Matrix& vec, int nev,
                Real shift = 0.0, int iop = 1);
 
  virtual Real Linfnorm() const;
 
  bool convert(Matrix& fullMat) const;
 
  virtual void dump(std::ostream& os, LinAlg::StorageFormat fmt, const char*);
  virtual bool load(const char* fileName, bool binary);
 
protected:
  bool assemble(int e, const Matrix& eM, const SAM& sam, Real* B = nullptr);
  bool multiply(size_t n, const Real* b, Real* c);
 
  virtual std::ostream& write(std::ostream& os) const;
 
private:
  Int_ ierr;     
  Int_ mpar[NS]; 
  Int_* msica;   
  Int_* msifa;   
  Int_* mtrees;  
  Int_* mvarnc;  
  Real* values;  
 
  std::vector<Int_>  iWork; 
  std::vector<Int_>* jWork; 
  std::vector<Real>  rWork; 
 
#ifdef USE_INT64
  struct SAM64
  {
    Int_* mpar;   
    Int_* mpmnpc; 
    Int_* mmnpc;  
    Int_* madof;  
    Int_* mpmceq; 
    Int_* mmceq;  
    Int_* meqn;   
    int*  minex;  
 
    SAM64(const SAM& sam);
    ~SAM64();
    std::pair<int,int> getNodeAndLocalDof(int ieq, bool) const;
  };
 
  bool sharedSam = false; 
#else
  using SAM64 = SAM; 
#endif
  SAM64* mySam; 
};
 
#endif