EMM_BlockEquilibriumMatrix.h

Go to the documentation of this file.

#ifndef EMM_BlockEquilibriumMatrix_H
#define EMM_BlockEquilibriumMatrix_H

//matrix inheritance : mask vector not used
#include "MATH_Matrix.h"
#include "MATH_ArrayVector.h"

//field
#include "EMM_RealField.h"

class MATH_Solver;
DEFINE_SPTR(EMM_DisplacementOperator);

DEFINE_SPTR(EMM_BlockEquilibriumMatrix);
DEFINE_SVPTR(EMM_BlockEquilibriumMatrix);
class EMM_BlockEquilibriumMatrix : public virtual MATH_Matrix {
  
    SP_OBJECT(EMM_BlockEquilibriumMatrix);
    // ATTRIBUTES
public:
    
  

private:
    //size of the matrix : nBlocks x blockSize
    tUIndex mSize;
    
    //block size
    tDimension mDimension;
    
    //for solve A.Y=B with work vector W
    SP::MATH_Vector mW,mY,mB;
    //preconditionner
    SP::MATH_Vector mD;
    
    mutable SP::MATH_Vector mZ;
    
    WPC::EMM_DisplacementOperator mOperator;
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_BlockEquilibriumMatrix(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_BlockEquilibriumMatrix(void);

public:
   
    virtual SP::MATH_Matrix NewInstance() const {
        return New();
    }
    
    inline static SP::EMM_BlockEquilibriumMatrix New(SPC::EMM_DisplacementOperator op,
                                                     const tDimension& dim) {
        SP::EMM_BlockEquilibriumMatrix p(new EMM_BlockEquilibriumMatrix(),
                                    EMM_BlockEquilibriumMatrix::Delete());
        p->setThis(p);
        p->mOperator=op;
        p->mDimension=dim;
        return p;
    };
    
    inline static SP::EMM_BlockEquilibriumMatrix New() {
        SP::EMM_BlockEquilibriumMatrix p(new EMM_BlockEquilibriumMatrix(),
                                         EMM_BlockEquilibriumMatrix::Delete());
        p->setThis(p);
        return p;
    };
    
    // SET methods 
 
public:

    virtual  void setSize(const tUIndex& nRows,const tUIndex& nCols)  {
        mSize=((nRows>nCols)?nRows:nCols)*mDimension;
        mW->setSize(mSize);
    }

    inline const MATH_Vector& getWorkArray()  const {
        return *mW.get();
    }

 
    
    // GET methods
    virtual tUIndex getRowsNumber() const {
        return mSize;
    }
    virtual tUIndex getColumnsNumber() const {
        return mSize;
    }
    
public:
   
    virtual tULLInt getMemorySize() const {
        return MATH_Matrix::getMemorySize()+mW->getMemorySize()+mB->getMemorySize()+mY->getMemorySize()+mZ->getMemorySize();
    }
    

public:
  
    
protected:
  
    
public:
    virtual void product(const tReal& beta,const MATH_Vector& x,const tReal& alpha, MATH_Vector& y) const;
    
    
    virtual void product(const tReal& alpha,const MATH_Vector& x,MATH_Vector& y) const;

    virtual void product(const MATH_Vector& x,MATH_Vector& y) const;
   


    
    
public:

    virtual tBoolean solve(MATH_Solver& solver,EMM_RealField& X,EMM_RealField& B);
 
    
   
    virtual const MATH_Vector& conditioning(const MATH_Vector& x) const;

  
    void computeDiagonalConditioner();
    
  
};

#endif