EMM_CondensedMassMatrix.h

Go to the documentation of this file.

#ifndef EMM_CondensedMassMatrix_H
#define EMM_CondensedMassMatrix_H


#include "EMM_CanonicalMassMatrix.h"

#include "MATH_ArrayVector.h"


DEFINE_SPTR(EMM_CondensedMassMatrix);
DEFINE_SVPTR(EMM_CondensedMassMatrix);
class EMM_CondensedMassMatrix : public  virtual EMM_CanonicalMassMatrix  {
  
    SP_OBJECT(EMM_CondensedMassMatrix);
    // ATTRIBUTES
public:
    
  
    

private:

    //indicates to use direct solver or iterative solver
    tBoolean mIsSolverExplicit;

    //indicates if the symmetric dot is applied to the condensed symmetric matrix
    tBoolean mIsCondensedSymmetricDot;
 
    //diagonal vector of size nPoints
    SP::MATH_ArrayVector mDiagonal;
  
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_CondensedMassMatrix(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_CondensedMassMatrix(void);

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

    inline void setIsSolverExplicit(const tBoolean& b) {
        mIsSolverExplicit=b;
    }
      
    
    // GET methods
  
  
    
public:
    virtual tULLInt getMemorySize() const {
        return EMM_CanonicalMassMatrix::getMemorySize()+mDiagonal->getSize();
    }
 
  
    
public:
    // OTHERS methods

    virtual void discretize(const EMM_Grid3D& mesh,SPC::EMM_LimitConditionArray lc);
protected:
    virtual void product(const tUIndex& n,
                         const tReal& beta,
                         const tUCInt& incX,
                         const tReal* x,
                         const tReal& alpha,
                         const tUCInt& incY,tReal* y) const {
        product(n,incX,beta,x,alpha,y);
    }
    
private:
      
    void product(const tUIndex& n,
                 const tDimension& dim,
                 const tReal& beta,
                 const tReal* x,
                 const tReal& alpha,
                 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);
    
    tBoolean solve(EMM_RealField& B);
    
    virtual void product(const tReal& beta,const MATH_Vector& x,const tReal& alpha, MATH_Vector& y) const {
        if (alpha==0) {
            product(beta,x,y);
            return;
        }
        
        if (beta==0) {
            y.dot(alpha);
            return;
        }
       
        //verify the size of X
        tUIndex nCols=getColumnsNumber();
        tUIndex nX=x.getSize();
        tDimension dim=nX/nCols;
        nX/=dim;
        if (nX!=getColumnsNumber()) {
            throw CORE_Exception("emicrom/math/solver",
                                 "EMM_CondensedMassMatrix::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();
        nY/=dim;
        if (nY!=getRowsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "EMM_CondensedMassMatrix::product(beta,X,alpha,Y)",
                                 "error in dimension of vector Y : "+CORE_Integer::toString(nY)+" != "+
                                 CORE_Integer::toString(getRowsNumber()));
        
      
      

        //compute the product
        //y=alpha.alpha+beta.T.x
        product(nX,dim,beta,&x[0],alpha,&y[0]);
    }
    virtual void product(const tReal& alpha,const MATH_Vector& x,MATH_Vector& y) const {
    
        //pathological cases
        if (alpha==0) {
            y.setSize(getRowsNumber());
            y.init(0);
            return;
        }
        
        if (alpha==1) {
            product(x,y);
            return;
        }

        //set the size of y
        y.setSize(getRowsNumber());
        
        //verify the size of X
        tUIndex nCols=getColumnsNumber();
        tUIndex nX=x.getSize();
        tDimension dim=nX/nCols;
        nX/=dim;
       
        if (nX!=getColumnsNumber()) {
            throw CORE_Exception("emicrom/math/solver",
                                 "EMM_CondensedMassMatrix::product(beta,X,Y)",
                                 "error in dimension of vector X :"+CORE_Integer::toString(nX)+" != "+
                                 CORE_Integer::toString(getColumnsNumber()));
            
        }
        
        
        //compute the product
        //y=alpha.T.X
        product(nX,dim,alpha,&x[0],0.,&y[0]);
        
    }

    virtual void product(const MATH_Vector& x,MATH_Vector& y) const {
         
        //verify the size of X
        tUIndex nCols=getColumnsNumber();
        tUIndex nX=x.getSize();
        tDimension dim=nX/nCols;
        nX/=dim;
        if (nX!=getColumnsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "EMM_CondensedMassMatrix::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
        //y=T.X
        product(nX,dim,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 {
        return EMM_CanonicalMassMatrix::toString();
    }
    
    
    
  
};

#endif