EMM_MassMatrix.h

Go to the documentation of this file.

#ifndef EMM_MassMatrix_H
#define EMM_MassMatrix_H

#include "EMM_Object.h"

#include "EMM_Array.h"
#include "EMM_RealField.h"

class EMM_Grid3D;

class MATH_Solver;

DEFINE_SPTR(EMM_MassMatrix);
DEFINE_SVPTR(EMM_MassMatrix);
class EMM_MassMatrix : public   virtual EMM_Object {
  
    SP_OBJECT(EMM_MassMatrix);
    // ATTRIBUTES
public:
    
  
    
    /* \brief computes \f$ \int_{\hat \omega} \hat \Phi_i \har \Phi_j d{\hat \omega} = |\hat \omega| INT_PHI2[i+8.j]/(H_i . H_j . INT_PHI2_FACTOR) \f$ with \f$ i \leq j \f$in a pack storage by column
     */
    static const tUCInt INT_PHI2[];
    static const tUCInt INT_PHI2_FACTOR;

private:

    //size of the matrix : nBlocks x size of blocks
    tUIndex mSize;
    
    //number of points in all directions
    tUInteger mPointsNumber[3];


    //periodicity indicator in 6 bytes
    tCellFlag mPeriodicity;
    
    //indicator number of neighbors at each cell
    SPC::EMM_CellFlagArray mNeighborsIndicator;
    

    SPC::EMM_LimitConditionArray mLimitConditionPoints;
    
    tReal mVolume;

    tUSInt mBlockSize;
  
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_MassMatrix(void);
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_MassMatrix(void) ;

public:
   
    
    
    // SET methods 

protected:
    inline void setBlockSize(const tUSInt& b) {
        mBlockSize=b;
    }
    
public:
  
    inline void setLimitConditionPoints(SPC::EMM_LimitConditionArray pts) {
        mLimitConditionPoints=pts;
    }
    
    inline void setPeriodicIndicator(const tCellFlag& p)  {
        mPeriodicity=p;
    }
    
   
    virtual void setSize(const tUIndex& nRows,const tUIndex& nCols) {
        mSize=nRows;
    }
    
   
    inline void setPointsNumber(const tUInteger& Px,const tUInteger& Py,const tUInteger& Pz)  {
        mSize=1;
        tUInteger *Ps=mPointsNumber;
        *Ps=Px;mSize*=*Ps;Ps++;
        *Ps=Py;mSize*=*Ps;Ps++;
        *Ps=Pz;mSize*=*Ps;
        mSize*=mBlockSize;
        
    }

    inline void setNeighborsIndicator(SPC::EMM_CellFlagArray neighbors) {
        mNeighborsIndicator=neighbors;
    }

  
    /* \brief set the volume of a cell of a mesh
     * @param vol: volume of a cell
     */
    inline void setElementVolume(const tReal & v) {
        mVolume=v;
    }
    
    // GET methods
public:

    inline const EMM_LimitConditionArray& getLimitConditionPoints() const {
        return *mLimitConditionPoints.get();
    }
    
    inline const tUSInt& getBlockSize() const {
        return mBlockSize;
    }
    virtual tULLInt getMemorySize() const {
        return 0;
    }
    inline const EMM_CellFlagArray&  getNeighborsIndicator() const{
        if (mNeighborsIndicator.get()==null) throw CORE_Exception("emicrom/operators/magnetostriction",
                                                                   "EMM_MassMatrix::getNeighborsIndicators()",
                                                                   "neighbors indicators array is not set");
        return *mNeighborsIndicator.get();
    }
    
    
    inline const tUInteger& getPointsNumber(const tDimension& k) const {
        return mPointsNumber[k];
    }
    inline const tUInteger* getPointsNumber() const {
        return mPointsNumber;
    }
   
    virtual tUIndex getRowsNumber() const {
        return mSize;
    }
    virtual tUIndex getColumnsNumber() const {
        return mSize;
    }
    
    inline const tCellFlag& getPeriodicIndicator() const {
        return mPeriodicity;
    }

    inline tBoolean isXPeriodic() const {
        return ((mPeriodicity&3)!=0);
    }
    inline tBoolean isYPeriodic() const {
        return ((mPeriodicity&12)!=0);
    }
    inline tBoolean isZPeriodic() const {
        return ((mPeriodicity&48)!=0);
    }

    
    /* \brief @return  the volume of a cell of a mesh
    
     */
    inline const tReal& getElementVolume()  const {
        return mVolume;
    }
    
public:
    // OTHERS methods

    virtual void discretize(const EMM_Grid3D& mesh,SPC::EMM_LimitConditionArray lc);

    virtual tBoolean isSymmetric() const=0; 
    virtual tBoolean solve(MATH_Solver& solver,EMM_RealField& B)=0;
    
    virtual void product(const tReal& alpha,const EMM_RealField& X,
                         const tReal& beta,EMM_RealField& Y) const=0;

 
    virtual tReal symmetricDot(const EMM_RealArray& D,const EMM_RealField& X) const=0;

    virtual tReal symmetricDot(const EMM_RealField& X) const=0;

    
   
    
  
};

#endif