SparseMatrix.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _SPARSE_MATRIX_H
#define _SPARSE_MATRIX_H
 
#include "SystemMatrix.h"
#include <map>
#include <set>
#include <array>
 
typedef std::pair<size_t,size_t> IJPair;    
typedef std::map<IJPair,Real>    ValueMap;  
typedef ValueMap::const_iterator ValueIter; 
 
struct SuperLUdata;
 
 
class SparseMatrix : public SystemMatrix
{
public:
  enum SparseSolver { NONE, SUPERLU, S_A_M_G, UMFPACK };
 
  SparseMatrix(SparseSolver eqSolver = NONE, int nt = 1);
  explicit SparseMatrix(size_t m, size_t n = 0, SparseSolver eqsolver = NONE);
  SparseMatrix(const SparseMatrix& B);
  virtual ~SparseMatrix();
 
  virtual LinAlg::MatrixType getType() const;
 
  virtual SystemMatrix* copy() const { return new SparseMatrix(*this); }
 
  virtual bool lockPattern(bool doLock);
 
  void resize(size_t r, size_t c = 0, bool forceEditable = false);
 
  bool redim(size_t r, size_t c);
 
  size_t rows() const { return nrow; }
  size_t cols() const { return ncol; }
  size_t size() const { return editable ? elem.size() : A.size(); }
 
  virtual size_t dim(int idim = 1) const;
 
  Real& operator()(size_t r, size_t c);
  const Real& operator()(size_t r, size_t c) const;
 
  const ValueMap& getValues() const { return elem; }
 
  void printSparsity(std::ostream& os) const;
 
  void printFull(std::ostream& os) const;
 
  virtual void dump(std::ostream& os, LinAlg::StorageFormat format,
                    const char* label);
 
  virtual void initAssembly(const SAM& sam, char preAssembly);
 
  void preAssemble(const SAM& sam, bool delayLocking);
 
  virtual void preAssemble(const std::vector<IntVec>& MMNPC, size_t nel = 0);
 
  virtual void compressPattern();
 
  virtual void init();
 
  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);
 
  bool assembleCol(const RealArray& V, const SAM& sam, int n, size_t col);
 
  bool assembleCol(Real val, const SAM& sam, int n, size_t col)
  {
    return this->assembleCol(RealArray(1,val),sam,n,col);
  }
 
  virtual bool augment(const SystemMatrix& B, size_t r0, size_t c0);
 
  virtual bool truncate(Real threshold = Real(1.0e-16));
 
  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* rc = nullptr);
 
  void calcCSR(IntVec& iA, IntVec& jA) const;
 
  bool split(std::array<SparseMatrix,4>& Asub, const IntVec& meqn2) const;
 
  bool getColumn(size_t c, Vector& col) const;
 
  virtual Real Linfnorm() const;
 
  bool isFactored() const { return factored; }
 
protected:
  bool optimiseRows(bool transposed = false);
 
  bool optimiseCols();
 
  bool optimiseCols(const std::vector< std::set<int> >& dofc);
 
  bool solveSAMG(Vector& B);
 
  bool solveSLU(Vector& B);
 
  bool solveSLUx(Vector& B, Real* rcond);
 
  bool solveUMF(Vector& B, Real* rcond);
 
  virtual std::ostream& write(std::ostream& os) const;
 
public:
  static bool printSLUstat; 
 
private:
  char editable;
 
  size_t nrow; 
  size_t ncol; 
 
  ValueMap       elem; 
  SparseSolver solver; 
  SuperLUdata*    slu; 
  int      numThreads; 
  void*   umfSymbolic; 
 
protected:
  bool factored; 
 
  IntVec IA; 
  IntVec JA; 
  Vector  A; 
};
 
#endif