EMM_MatterField.h

Go to the documentation of this file.

#ifndef EMM_MatterIndexField_H
#define EMM_MatterIndexField_H

#include "EMM_Object.h"

#include "EMM_Array.h"
#include "EMM_RealArray.h"
#include "EMM_Matter.h"

#include "CORE_MorseArray.h"
#include "CORE_MorseArrayIterator.h"

#include "EMM_AnisotropyDirectionsField.h"


DEFINE_SPTR(EMM_MagneticExcitationOperator);

DEFINE_SPTR(EMM_MatterField);
class EMM_MatterField : public virtual EMM_Object {
    
    SP_OBJECT(EMM_MatterField);
    // ATTRIBUTES
    
public:
    static const tUIndex NO_MATTER;
    
private:
    tString mAnisotropyDirectionsFile;
   
    EMM_UIndexArray mMatterIndices;
    
    SV::EMM_Matter mMatters;

    //common adiemnsionized parameters for all matters
    tReal mL;//refrence length
    tReal mLe;//elastic reference length
    tReal mMsat;//reference magnetization at saturation
    tReal mTm;//characteristic magnetic time
    tReal mTed;//adimensionized characteristic elastic time
    tReal mEd;//adimensionized energy
    tReal mRhoVs2;//adimensionized factor for elasticity tensor

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

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

    // OPERATOR
    inline const tUIndex& operator[](const tUIndex& i) const {
        return mMatterIndices[i];
    }
    inline  tUIndex& operator[](const tUIndex& i) {
        return mMatterIndices[i];
    }
  
   
 
    // SET methods
    // ===========

    inline void setElasticTensorAdimensionizedParameter(const tReal& rhoVs2) {
        mRhoVs2=rhoVs2;
    }
    inline tReal getElasticTensorAdimensionizedParameter() const {
        if (mRhoVs2==0) return EMM_Object::Mu0*mMsat*mMsat;
        else return mRhoVs2;
    }
    inline void clear(){
        mMatterIndices.setSize(0);
        mMatters.clear();
    }
    
  
    
    inline void setSize(const tUIndex& n){
        mMatterIndices.setSize(n);
    }
    
    inline void addMatter(const SP::EMM_Matter matter){
        mMatters.add(matter);
    }

    inline void initIndices() {
        mMatterIndices.initArray(NO_MATTER);
    }

    inline void setMatters(const SV::EMM_Matter& matters) {
        mMatters=matters;
    }


    inline void setAnisotropyDirectionsFile(const tString& fn) {
        mAnisotropyDirectionsFile=fn;
    }
    
    // GET methods
    // ==========
   
    
    
public:
    inline const tString&  getAnisotropyDirectionsFile() const {
        return mAnisotropyDirectionsFile;
    }
    inline tUIndex getSize() const {
        return mMatterIndices.getSize();
    }
    inline tBoolean isUniform() const {
        return (mMatterIndices.getSize()==1);
    }
   
    inline tUIndex getMattersNumber() const {
        return mMatters.getSize();
    }
   
   
    inline const SV::EMM_Matter& getMatters() const {
        return mMatters;
    }
    inline SV::EMM_Matter& getMatters()  {
        return mMatters;
    }

    inline const EMM_Matter& getMatter(const tUIndex& i)  const {
        if (i>=mMatters.getSize()) throw EMM_Exception("EMM_MatterField::getMatter("+CORE_Integer::toString(i)+")",
                                                       "index out of bound");
        const EMM_Matter* mat=mMatters.get(i);
        if (mat==null)   throw EMM_Exception("EMM_MatterField::getMatter("+CORE_Integer::toString(i)+")",
                                                       "null matter");
        return *mat;
    }
    inline EMM_Matter& getMatter(const tUIndex& i) {
        if (i>=mMatters.getSize()) throw EMM_Exception("EMM_MatterField::getMatter("+CORE_Integer::toString(i)+")",
                                                       "index out of bound");
        EMM_Matter* mat=mMatters.get(i);
        if (mat==null)   throw EMM_Exception("EMM_MatterField::getMatter("+CORE_Integer::toString(i)+")",
                                                       "null matter");
        return *mat;
    }
 
    inline const EMM_UIndexArray& getMatterIndices() const {
        return mMatterIndices;
    }
    
    template<class T>
    tBoolean getMatterParameterDistribution(const tFlag& k,EMM_Array<T>& vs) const;

    template<class T>
    tBoolean getMatterParameterDistribution(const tFlag& k,CORE_MorseArray<T>& vs) const;

  
    
    void adimensionize(const tReal& dmin,const tReal& dmax);

    inline const tReal& getReferenceMagnetizationAtSaturation() const {
        return mMsat;
    }
    inline const tReal& getReferenceLength() const {
        return mL;
    }
    inline const tReal& getReferenceElasticLength() const {
        return mLe;
    }
    inline const tReal& getCharacteristicMagneticTime() const {
        return mTm;
    }
    inline const tReal& getAdimensionizedElasticTime() const {
        return mTed;
    }
    inline const tReal& getAdimensionizedEnergy() const {
        return mEd;
    }
    
private:
    inline tReal computeReferenceMagnetizationAtSaturation() const {
        vector<SP::EMM_Matter>::const_iterator iMatter=mMatters.begin();
        tReal Msi,Ms=1.;
        if (iMatter!=mMatters.end()) {
            Ms=(*iMatter)->getMagnetizationAtSaturation();
            iMatter++;
        }
        while (iMatter!=mMatters.end()) {
            Msi=(*iMatter)->getMagnetizationAtSaturation();
            //Ms=sup(Ms,Msi)
            Ms=(Ms<Msi)?Msi:Ms;
            iMatter++;
        }
        return Ms;
    }
public:
    tBoolean computeAnisotropyDirectionsField(EMM_AnisotropyDirectionsField& dirF) const;
   

    SP::EMM_MagneticExcitationOperator createAnisotropyOperator() const;

   
    
public:
    // IO Methods
    // ==========
    
    
    tBoolean loadFromFile(const tString& fileName);
    

private:
    tBoolean loadFromLOCFile(const tString& fileName);

    tBoolean loadFromANIFile(const tString& fileName);

public:
    static tBoolean saveToFile(const tString& fileName,
                               const EMM_UIndexArray& matterIndices);
    
    inline tBoolean saveToFile(const tString& fileName) const {
        return saveToFile(fileName,mMatterIndices);
    }
   
  
    
public:

    virtual tString toString() const;
   


};


#include "EMM_MatterField.hpp"

#endif