EMM_BlockMassMatrix.h

Go to the documentation of this file.

#ifndef EMM_BlockMassMatrix_H
#define EMM_BlockMassMatrix_H

//interface class
#include "EMM_MassMatrix.h"

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

//field
#include "EMM_RealField.h"

DEFINE_SPTR(EMM_BlockMassMatrix);
DEFINE_SVPTR(EMM_BlockMassMatrix);
class EMM_BlockMassMatrix : public  virtual EMM_MassMatrix, public virtual MATH_Matrix {
  
    SP_OBJECT(EMM_BlockMassMatrix);
    // ATTRIBUTES
public:
    
  

private:

    //for solveib A.Y=B with work vector W
    SP::MATH_Vector mW,mY,mB;
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_BlockMassMatrix(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_BlockMassMatrix(void);

public:
   
    virtual SP::MATH_Matrix NewInstance() const {
        return New();
    }
    
    inline static SP::EMM_BlockMassMatrix New() {
        SP::EMM_BlockMassMatrix p(new EMM_BlockMassMatrix(),
                                    EMM_BlockMassMatrix::Delete());
        p->setThis(p);
        return p;
    };
    
    // SET methods 
 
public:

    virtual  void setSize(const tUIndex& nRows,const tUIndex& nCols)  {
        EMM_MassMatrix::setSize(nRows*getBlockSize(),nCols*getBlockSize());
        mW->setSize(nRows*getBlockSize());
    }

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

public:
    virtual tBoolean isSymmetric() const {
        SP::MATH_ArrayVector W=MATH_ArrayVector::New();
        return MATH_Matrix::isSymmetric(1.e-12,*W.get());
    }
    
protected:
    virtual void product(const tUIndex& n,
                         const tReal& alpha,
                         const tUSInt& incX,
                         const tReal* x,
                         const tReal&  beta,
                         const tUSInt& incY,tReal* y) const {
        product(n,incX,alpha,x,beta,y);
    }
    
    
private:
    
    void product(const tUIndex& n,
                 const tDimension&  dim,
                 const tReal& alpha,
                 const tReal* x,
                 const tReal& beta,
                 tReal* y) const;

    
    
    
private:
    tReal symmetricDot(const tUIndex& n,
                       const tDimension& dim,
                       const tReal* x,
                       const tReal* y) const;
    
    tReal symmetricDot(const tUIndex& n,
                       const tDimension& dim,
                       const tReal* D,
                       const tReal* x,
                       const tReal* y) const;
    

public:

    virtual tBoolean solve(MATH_Solver& solver,EMM_RealField& B);
    
    virtual void product(const tReal& alpha,const MATH_Vector& x,const tReal& beta, MATH_Vector& y) const {
       
        //verify the size of X
        tUIndex nX=x.getSize();
        if (nX!=getColumnsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "EMM_BlockMassMatrix::product(beta,X,alpha,Y)",
                                 "error in dimension of vector X "+CORE_Integer::toString(nX)+" != "+
                                 CORE_Integer::toString(getColumnsNumber()));
        
        //verify the size  of B = size of X
        tUIndex nY=y.getSize();
        if (nY!=getRowsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "EMM_BlockMassMatrix::product(beta,X,alpha,Y)",
                                 "error in dimension of vector Y "+CORE_Integer::toString(nY)+" != "+
                                 CORE_Integer::toString(getRowsNumber()));
        
      
      

        //compute the product
        product(nX/3,3,alpha,&x[0],beta,&y[0]);
    }
    
    virtual void product(const tReal& alpha,const MATH_Vector& x,MATH_Vector& y) const {
    

        //set the size of y
        y.setSize(getRowsNumber());
        
        //verify the size of X
        tUIndex nX=x.getSize();
        if (nX!=getColumnsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "EMM_BlockMatrix::product(beta,X,Y)",
                                 "error in dimension of vector X "+CORE_Integer::toString(nX)+" != "+
                                 CORE_Integer::toString(getColumnsNumber()));
        
      

        
        //compute the product
        product(nX/3,3,alpha,&x[0],0.,&y[0]);
        
    }

    virtual void product(const MATH_Vector& x,MATH_Vector& y) const {
        //verify the size of X
        tUIndex nX=x.getSize();
        if (nX!=getColumnsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "EMM_BlockMassMatrix::product(X,Y)",
                                 "error in dimension of vector X "+CORE_Integer::toString(nX)+" != "+
                                 CORE_Integer::toString(getColumnsNumber()));
        //set the size of y
        y.setSize(getRowsNumber());
        
        

        //compute the product
        product(nX/3,3,1.,&x[0],0.,&y[0]);
        
    }

    virtual void  product(const tReal& alpha,const EMM_RealField& X,
                          const tReal& beta,EMM_RealField& Y) const;

    
   
    
    virtual tReal symmetricDot(const EMM_RealField& X) const;

    virtual tReal symmetricDot(const EMM_RealArray& W,const EMM_RealField& X) const;

    
    virtual tString toString() const;
    
    
    
  
};

#endif