SM_Material.h

#ifndef SM_Material_H
#define SM_Material_H
 
//super class header
#include "SM_Object.h"
 
//constant header
#include "SM_Constants.h"
 
//array utilities functions header
#include "functions_array.h"
 
//crystal struature of the material
#include "SM_CrystalStructure.h"
 
class SM_Material : public SM_Object {
    
    //attributes
private :
 
    //physical variables
    //==================
 
    
    
    //atomic spin moment in Mu_B factor
    tReal mMu_s;
    //atomic spin moment in unit of internal system
    tReal mMu_s_SIU;
 
    //exchange energy factor
    tReal mJ;
 
    //dmi energy factor
    std::array<tReal,SM_Constants::DIM> mD;
 
    //spin wave MF correction
    tReal mEpsilon;
   
 
    //crystal type
    tFlag mCrystalType;
    
    //anisotropy energy factor
    tReal mK;
    
    //anisotropy direction
    std::valarray<tReal> mU;
    
 
    //name of the material
    tString mName;
 
    //crystal structure
    CORE_UniquePointer<SM_CrystalStructure> mCrystalStructure;
 
    //Characteristic variables
    //==========================
  
        
    //characteristic energy in joules : \f$ \bar e = \mu_0 . \mu_s^2 a^{-3} \f$
    tReal mCEnergy;
    //characteristic field in T  : \f$ \bar h = \mu_0 . \mu_s a^{-3} \f$
    tReal mCField;
    //characteritisc time in s : \f$ \bar t=\frac{a^3}{\gamma.\mu_0.\mu_s} \f$
    tReal mCTime;
 
    //characteristic adimensionized Heisenberg coefficient : \f$ e_{exc}^i= - \tilde J \sum_{j \neq i}  . <S_i,S_j> \f$
    tReal mCJ;
    //characteristic adimensionized  DMI coefficient : \f$ e_{dmi}^i= - \tilde D \sum_{j \neq i}  . S_i \wedge S_j \f$
    std::array<tReal,SM_Constants::DIM> mCD;
    //characteristic adimenzionized Anisotropy coefficient : \f$ e_{ani}^i= \tilde K . \Phi_U(S_i) \f$
    tReal mCK;
    //characteristic adimensionized dipolar coefficient : \f$ e_{dip}^i= -\frac{\tilde E_{dip}. \mu_s^2 }{4.\pi} . \sum_{j\neq i} F(S_i,S_j,r_{ij}) \f$
    tReal mCEdip;
    //characteristic adimensionied energy derivative factor \f$ h = -\frac{1}{\tilde \mu_s} \frac{\partial e}{\partial S} \f$ where \f$ E= \bar e e \f$ and \f$ H= \bar h h \f$
    tReal mCDe;
    
public:
    // CONSTRUCTORS 
    SM_Material(void);
      
    
    // DESTRUCTORS 
    virtual ~SM_Material(void);
    
public : 
 
    //Instance building
    //=================
    
   
 
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+=mU.size()*sizeof(tReal);
        mem+=mCD.size()*sizeof(tReal);
        mem+=mD.size()*sizeof(tReal);
        return mem;
    }
    //Instance building
    //=================
    
    inline static CORE_UniquePointer<SM_Material> New() {
        return CORE_UniquePointer<SM_Material>(new SM_Material(),SM_Material::Delete());
    }
    //SET & GET methods
 
    inline void setCrystalStructure(CORE_UniquePointer<SM_CrystalStructure> cStructure) {
        mCrystalStructure=std::move(cStructure);
    }
    inline const SM_CrystalStructure& getCrystalStructure() const {
        return *mCrystalStructure.get();
    }
    inline SM_CrystalStructure& getCrystalStructure() {
        return *mCrystalStructure.get();
    }
    inline tBoolean hasCrystalStructure() const {
        return (mCrystalStructure.get()!=null);
    }
    
    
 
    //set & get methods
public:
    inline void setName(const tString& name) {
        mName=name;
    }
 
    inline const tString& getName() const {
        return mName;
    }
  
 
 
    
    inline void setAtomicSpinMoment(const tReal& mu_s) {
        mMu_s=mu_s;
    }
    inline const tReal& getAtomicSpinMoment() const {
        return mMu_s;
    }
    inline const tReal& getAtomicSpinMoment_SIU() const {
        return mMu_s_SIU;
    }
    
    inline void setAnisotropyType(const tFlag& crystalType) {
        mCrystalType=crystalType;
    }
    inline const tFlag& getAnisotropyType() const {
        return mCrystalType;
    }
    
    inline void setAnisotropyEnergyFactor(const tReal& k) {
        mK=k;
    }
    inline const tReal&  getAnisotropyEnergyFactor() const {
        return mK;
    }
 
    inline void setAnisotropyDirections(const std::array<tReal,SM_Constants::DIM*SM_Constants::DIM>& U) {
        mU.resize(U.size());
        const tReal *iU=U.data();
        for(auto& Uk:mU) {
            Uk=(*iU);
            iU++;
        }
    }
    inline void setAnisotropyDirections(const std::vector<tReal>& U) {
        mU.resize(U.size());
        tReal *iU=&mU[0];
        for(const auto& Uk:U) {
            (*iU)=Uk;
            iU++;
        }
    }
    inline const std::valarray<tReal>& getAnisotropyDirections() const {
        return mU;
    }
    
    inline void setExchangeEnergyFactor(const tReal& J) {
        mJ=J;
    }
    inline const tReal&  getExchangeEnergyFactor() const {
        return mJ;
    }
  
    inline void setDMIEnergyFactor(const std::array<tReal,SM_Constants::DIM>& D) {
        mD=D;
    }
    inline const std::array<tReal,SM_Constants::DIM>&  getDMIEnergyFactor() const {
        return mD;
    }
 
    inline void setSpinWaveMFCorrection(const tReal& eps)  {
        mEpsilon=eps;
    }
    inline const tReal& getSpinWaveMFCorrection() const {
        return mEpsilon;
    }
  
    void computeCharacteristicValues(const tBoolean& isAdimensionized);
  
    
    inline const tReal&  getCharacteristicTime() const {
        return mCTime;
    }
    inline const tReal&  getCharacteristicEnergy() const {
        return mCEnergy;
    }
    inline const tReal&  getCharacteristicField() const {
        return mCField;
    }
 
    
    inline const tReal& getAdimensionizedExchangeEnergyFactor() const {
        return mCJ;
    }
     
    inline const std::array<tReal,SM_Constants::DIM>& getAdimensionizedDMIEnergyFactor() const {
        return mCD;
    }
    
    inline const tReal& getAdimensionizedAnisotropyEnergyFactor() const {
        return mCK;
    }  
    inline const tReal& getAdimensionizedDipolarEnergyFactor() const {
        return mCEdip;
    }
    inline const tReal& getAdimensionizedDerivativeEnergyFactor() const {
        return mCDe;
    }
  
    
public:
  
    virtual tString toString() const override;
};
 
#endif