EMM_Matter.h

Go to the documentation of this file.

#ifndef EMM_Matter_H
#define EMM_Matter_H

#include "EMM_Object.h"

#include "CORE_Out.h"
#include "CORE_Array.h"

DEFINE_SPTR(EMM_Matter);
DEFINE_SVPTR(EMM_Matter);
class EMM_Matter : public virtual EMM_Object {
  
    SP_OBJECT(EMM_Matter);
    // ATTRIBUTES
public:
    //initialize in .h file in order to use it in switch command
    static const tFlag UNIAXIAL_ANISOTROPY=0;
    static const tFlag PLANAR_ANISOTROPY=1;
    static const tFlag CUBIC_ANISOTROPY=2;
    static const tString ANISOTROPY[];

    
    //parameters flag
    static const tFlag N_PARAMETERS=30;
    
   

    //physical parameters
    static const tFlag ALPHA=0;
    
    static const tFlag Ms=1;
    static const tFlag A=2;
    static const tFlag CRYSTAL_TYPE=3;
    static const tFlag K1=4;
    static const tFlag K2=5;
    static const tFlag ANISOTROPY_DIRECTIONS=6;
    static const tFlag LAMBDA_E=7;
    static const tFlag LAMBDA_M=8;
    static const tFlag RHO=9;
    
    //adimensionized
    static const tFlag Ad=10;
    static const tFlag K1d=11;
    static const tFlag K2d=12;
    static const tFlag LAMBDA_Ed=13;
    static const tFlag LAMBDA_Md=14;
    static const tFlag RHOd=15;
    
    //characteritics data
    static const tFlag LEX=20;//the length below which the exchange interaction dominates typical magnetostatic fields
    static const tFlag D_LEX=23;//exchange influence
    static const tFlag BLOCH=21;//length below which the exchange interaction dominates anisotropy effects
    static const tFlag Q=22;//magnetic hardness

   
private:


    
    tString mName;  

    //1D parameter of the matter
    tReal mParameters[N_PARAMETERS];

    //dimensions of parameters
    tUCInt mParametersDimension[N_PARAMETERS];
    
    tReal mAnisotropyDirections[9];

    
    CORE_RealArray mLambdaE;
    CORE_RealArray mLambdaM;
    CORE_RealArray mLambdaEd;
    CORE_RealArray mLambdaMd;
   
    


    // ASSOCIATION

  
    
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_Matter(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_Matter(void);   
  
  
public:
    // NEW method

    inline static SP::EMM_Matter New() {
        SP::EMM_Matter p(new EMM_Matter(),EMM_Matter::Delete());
        p->setThis(p);
        return p;
    };

    virtual void copy(const EMM_Matter& mat);

 
    
    // SET methods

    
    inline void setName(const tString& name) {
        mName=name;
    }; 

    //demagnetized parameter
    //======================
    
    inline void setAbsorptionParameter(const tReal& v) {
        mParameters[ALPHA]=v;
    };

    inline void setMagnetizationAtSaturation(const tReal& v) {
        mParameters[Ms]=v;
    };

    //exchange
    //==========
    inline void setExchangeConstant(const tReal& v) {
        mParameters[A]=v;
    };

    //Anistropy
    //==========
    inline void setAnisotropy(const tFlag& ani) {
        mParameters[CRYSTAL_TYPE]=ani;
    };
    inline void setMainAnisotropyConstant(const tReal& k) {
        mParameters[K1]=k;
    };
    inline void setSecondAnisotropyConstant(const tReal& k) {
        mParameters[K2]=k;
    }; 
    inline void setAnisotropyDirections(const tReal dir[9]) {
        for (tUSInt k=0;k<9;k++) mAnisotropyDirections[k]=dir[k];
        
    }
    inline void setAnisotropyDirection(const tSInt& i,const tReal dir[3]) {
        ASSERT_IN(i<3);
        for(tUSInt index=0;index<3;index++)
            mAnisotropyDirections[3*i+index]=dir[index];
    }
    
    inline void setAnisotropyDirectionCoordinate(const tSInt& i,const tSInt& k,const tReal & dir) { 
        ASSERT_IN(i<3);
        ASSERT_IN(k<3);
        mAnisotropyDirections[3*i+k]=dir;
    } 

  
    
    //magnetstriction elastic tensor
    //===============================
   
    inline void setVolumicMass(const tReal& rho) {
        mParameters[RHO]=rho;
    }
    inline const tReal&  getVolumicMass() const {
        return mParameters[RHO];
    }
    inline const tReal&  getAdimensionizedVolumicMass() const {
        return mParameters[RHOd];
    }
    inline void setElasticTensor(const tReal& lambdaE)  {
        mLambdaE.initArray(lambdaE);
    }
   
    inline void setElasticTensor(const tUSInt& i,const tUSInt& j,const tUSInt& k,const tUSInt& l,const tReal& lambdaE)  {
        mLambdaE.setValue(getTensorIndex(mLambdaE.getSize(),i,j,k,l),lambdaE);
        mLambdaE.setValue(getTensorIndex(mLambdaE.getSize(),i,j,l,k),lambdaE);
        
        mLambdaE.setValue(getTensorIndex(mLambdaE.getSize(),j,i,k,l),lambdaE);
        mLambdaE.setValue(getTensorIndex(mLambdaE.getSize(),j,i,l,k),lambdaE);

        mLambdaE.setValue(getTensorIndex(mLambdaE.getSize(),k,l,i,j),lambdaE);
        mLambdaE.setValue(getTensorIndex(mLambdaE.getSize(),k,l,j,i),lambdaE);
        
        mLambdaE.setValue(getTensorIndex(mLambdaE.getSize(),l,k,i,j),lambdaE);
        mLambdaE.setValue(getTensorIndex(mLambdaE.getSize(),l,k,j,i),lambdaE);
    }
        
    inline void setElasticTensor(const vector<tReal>& lambdaE)  {
        mLambdaE.initArray(lambdaE);
    }
    inline void setElasticTensor(const tUSInt& n,const tReal* lambdaE)  {
        mLambdaE.initArray(n,lambdaE);
    }
  
        
    //magnetostriction Magnetic tensor
    //================================
    
    inline void setMagneticTensor(const tReal& lambdaM)  {
        mLambdaM.initArray(lambdaM);
    }
   
    
    inline void setMagneticTensor(const tUSInt& i,const tUSInt& j,const tUSInt& k,const tUSInt& l,const tReal& lambdaM)  {
        mLambdaM.setValue(getTensorIndex(mLambdaM.getSize(),i,j,k,l),lambdaM);
        mLambdaM.setValue(getTensorIndex(mLambdaM.getSize(),i,j,l,k),lambdaM);
        
        mLambdaM.setValue(getTensorIndex(mLambdaM.getSize(),j,i,k,l),lambdaM);
        mLambdaM.setValue(getTensorIndex(mLambdaM.getSize(),j,i,l,k),lambdaM);

        mLambdaM.setValue(getTensorIndex(mLambdaM.getSize(),k,l,i,j),lambdaM);
        mLambdaM.setValue(getTensorIndex(mLambdaM.getSize(),k,l,j,i),lambdaM);
        
        mLambdaM.setValue(getTensorIndex(mLambdaM.getSize(),l,k,i,j),lambdaM);
        mLambdaM.setValue(getTensorIndex(mLambdaM.getSize(),l,k,j,i),lambdaM);
    }
    inline void setMagneticTensor(const vector<tReal>& lambdaM)  {
        mLambdaM.initArray(lambdaM);
    }
    
    inline void setMagneticTensor(const tUSInt& n,const tReal* lambdaM)  {
        mLambdaM.initArray(n,lambdaM);
    }
 
   
    // GET methods  

    inline const tReal& getParameter(const tUSInt& k) const {
        switch(k) {
        case ANISOTROPY_DIRECTIONS:
            return mAnisotropyDirections[0];
            break;
        case LAMBDA_E:
            return mLambdaE[0];
            break;
        case LAMBDA_M:
            return mLambdaM[0];
            break;
        case LAMBDA_Ed:
            return mLambdaEd[0];
            break;
        case LAMBDA_Md:
            return mLambdaMd[0];
            break;
        default:
            return mParameters[k];
        }
    }
    inline tReal& getParameter(const tUSInt& k)  {
       switch(k) {
        case ANISOTROPY_DIRECTIONS:
            return mAnisotropyDirections[0];
            break;
        case LAMBDA_E:
            return mLambdaE[0];
            break;
        case LAMBDA_M:
            return mLambdaM[0];
            break;
        case LAMBDA_Ed:
            return mLambdaEd[0];
            break;
        case LAMBDA_Md:
            return mLambdaMd[0];
            break;
        default:
            return mParameters[k];
        }
    }

    inline const tUCInt& getParameterDimension(const tFlag& k) const {
        return mParametersDimension[k];
    }
    inline const tString& getName() const {
        return mName;
    };
    inline const tReal& getAbsorptionParameter() const {
        return mParameters[ALPHA];
    };

    inline const tReal& getMagnetizationAtSaturation() const {
        return mParameters[Ms];
    }; 
    
  
    inline const tReal& getExchangeConstant() const {
        return mParameters[A];
    };
  
    inline tFlag  getAnisotropy()  const {
        return (tFlag) (mParameters[CRYSTAL_TYPE]+0.5);
        
    };
    inline const tReal&  getMainAnisotropyConstant() const {
        return mParameters[K1];
    };
    inline const tReal& getSecondAnisotropyConstant() const {
        return mParameters[K2];
    }; 
    inline const tReal* getAnisotropyDirections() const {
        return mAnisotropyDirections;
        
    }
    inline const tReal*  getAnistropyDirections(const tUIndex& i) const {
        return &mAnisotropyDirections[3*i];
    }
    inline tUCInt  getAnisotropyDirectionsNumber() const {
        tFlag t=mParameters[CRYSTAL_TYPE];
        if (t==UNIAXIAL_ANISOTROPY) return 1;
        else if (t==PLANAR_ANISOTROPY) return 1;
        else if (t==CUBIC_ANISOTROPY) return 3;
        return 3;
    }
    
private:
    inline static  tUIndex  getTensorIndex(const tUIndex& n,
                                           const tDimension& p,const tDimension& q,const tDimension& r,const tDimension& s) {
        tUCInt i,j;
        switch(n) {
        case 81://full tensor
            return s+3*(r+3*(q+3*p));//see EMM_4Tensor::getIndex(p,q,r,s,3))
        case 36://packed tensor
            if (p>=q) i=q+p*(p+1)/2;
            else i=p+q*(q+1)/2;

            if (r>=s) j=s+r*(r+1)/2;
            else j=r+s*(s+1)/2;

            return i+6*j;
        case 21://packed symmetric tensor
            if (p>=q) i=q+p*(p+1)/2;
            else i=p+q*(q+1)/2;
            
            if (r>=s) j=s+r*(r+1)/2;
            else j=r+s*(s+1)/2;

            if (i>=j) return j+(i*(i+1)/2);
            else return j+(i*(i+1)/2);
        }
        return 0;
    }
public:
   
    inline const CORE_RealArray& getElasticTensor() const {
        return mLambdaE;
    }
    inline CORE_RealArray& getElasticTensor() {
        return mLambdaE;
    }
    
    inline const CORE_RealArray& getMagneticTensor() const {
        return mLambdaM;
    }
    inline CORE_RealArray& getMagneticTensor() {
        return mLambdaM;
    }
    
    inline const CORE_RealArray& getAdimensionizedElasticTensor() const {
        return mLambdaEd;
    }
    inline CORE_RealArray& getAdimensionizedElasticTensor() {
        return mLambdaEd;
    }
    
    inline const CORE_RealArray& getAdimensionizedMagneticTensor() const {
        return mLambdaMd;
    }
    inline CORE_RealArray& getAdimensionizedMagneticTensor() {
        return mLambdaMd;
    }
    
    
    
   
    
    inline const tReal& getElasticTensor(const tDimension& i,const tDimension& j,const tDimension& k,const tDimension& l) const {
        return mLambdaE.getValue(getTensorIndex(mLambdaE.getSize(),i,j,k,l));
       
    }
   
  
    inline const tReal& getMagneticTensor(const tDimension& i,const tDimension& j,const tDimension& k,const tDimension& l) const {
        return mLambdaM.getValue(getTensorIndex(mLambdaM.getSize(),i,j,k,l));
    }
   
  
    //adimensionization of the matter variable
    //========================================
    
    void adimensionize(const tReal& Ms,const tReal& rhoVs2,const tReal& dmin,const tReal& dmax);

   
    
    inline const tReal& getAdimensionizedExchangeConstant() const {
        return mParameters[Ad];
    }; 
  
    inline const tReal& getExchangeLength() const {
        return  mParameters[LEX];
    }; 
    inline const tReal& getAdimensionizedMainAnisotropy() const {
        return mParameters[K1d];
    }
    inline const tReal& getAdimensionizedSecondAnisotropy() const {
        return mParameters[K2d];
    }
   
  
   
      
    inline const tReal& getAdimensionizedElasticTensor(const tDimension& i,const tDimension& j,const tDimension& k,const tDimension& l) const {
        return mLambdaEd.getValue(getTensorIndex(mLambdaEd.getSize(),i,j,k,l));
       
    }
    

  
    inline const tReal& getAdimensionizedMagneticTensor(const tDimension& i,const tDimension& j,const tDimension& k,const tDimension& l) const {
        return mLambdaMd.getValue(getTensorIndex(mLambdaMd.getSize(),i,j,k,l));
    }
    

public:
    // OTHERS methods

    static tBoolean loadMattersFromFile(const tString& fileName,SV::EMM_Matter& matters);
                                 
         
    static tBoolean saveMattersToFile(const tString& fileName,
                                      const SV::EMM_Matter& matters);
    

    
    tBoolean loadFromFile(const tString& fileName);         
   
    tBoolean loadFromStream(ifstream& stream,tString& lastUnreadLine);
    

    /* \brief save the matter in text file
     * @param fileName: file name of the material .mat
     * @return true if succeeded
     */
    tBoolean saveToFile(const tString& fileName)const;
   

    tBoolean saveToStream(ofstream& stream,
                          const tBoolean& writeHeader)const;

public:
    virtual tString toString() const;

  
};

#endif