SM_LandauLifschitzFunction.h

Go to the documentation of this file.

#ifndef SM_LandauLifschitzFunction_H
#define SM_LandauLifschitzFunction_H
 
//inherit class header
#include "SM_Object.h"
 
//field heaer
#include "SM_Field.h"
 
 
class SM_LandauLifschitzFunction : public  SM_Object {
  
    // ATTRIBUTES
  
public:
   
  
   
private:
 
   
    //alpha  parameter
    tReal mAlpha;
 
    //beta parameter
    tReal mBeta;
 
    //normalized mu
    tBoolean mIsMuNormalized;
  
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_LandauLifschitzFunction(void) {
        mAlpha=-1;
        mBeta=2;
        mIsMuNormalized=false;
    }
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~SM_LandauLifschitzFunction(void) {
    }
  
  
public:
 
 
      //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    
    
    // SET methods 
 
    inline void copy(const SM_LandauLifschitzFunction& LL) {
        mAlpha=LL.getAlpha();
        mBeta=LL.getBeta();
        mIsMuNormalized=LL.isMuNormalized();
    }
    inline void setAlpha(const tReal& v) {
        mAlpha=v;
    }
    inline void setBeta(const tReal& v) {
        mBeta=v;
    }
 
    inline void setIsMuNormalized(const tBoolean& v) {
        mIsMuNormalized=v;
    }
    
    // GET methods
    // ============
    
    inline const tReal&  getAlpha() const {
        return mAlpha;
    }
    
    inline const tReal&  getBeta() const {
        return mBeta;
    }
  
    inline tBoolean  isMuNormalized() const {
        return mIsMuNormalized;
    }
    
  
public:
    // OTHERS methods
    inline void computeFunction(const SM_RealField& Mu,const SM_RealField& B,SM_RealField& F) const {
        const tIndex& N=Mu.getElementsNumber();
        if (N!=B.getElementsNumber()) {
            throw SM_Exception("stochMagnet","SM_LandauLifschitzFunction::computeFunction(Mu,B,F)",
                               "incompatible size between Mu & B");
        }
       
        //set the output field dimension
        F.setElementsNumber(N);
        computeFunction(N,Mu.getDimension(),&Mu[0],&B[0],&F[0]);
    }
    inline void computeFunction(const tIndex& nParticles,const tDimension& dim,
                                  const tReal *mu,const tReal *B,tReal *F) const {
        if (mIsMuNormalized) computeNLLFunction(nParticles,dim,mu, B,F);
        else computeLLFunction(nParticles,dim,mu, B,F);
    }
 
private:
    inline void computeLLFunction(const tIndex& nParticles,const tDimension& dim,
                                  const tReal *mu,const tReal *B,tReal *F) const {
 
        ASSERT_IN(dim==3);
        
        //iterator on point
        tIndex p;
 
        //sMuB=<Mu,B>
        //sMuMu=<Mu,Mu>
        tReal sMuB,sMuMu;
        //iterator on mu
        const tReal *iMu=mu;
        //iterator on B
        const tReal *iB=B;
        //iterator on F
        tReal *iF=F;
        
        for (p=0;p<nParticles;p++) {//loop on point
            
         
            // A = alpha(  mu \wedge B + beta ( <\mu,B> \mu -  <\mu,\mu> B ) )
            const tReal& mu0=(*iMu);iMu++;
            const tReal& mu1=(*iMu);iMu++;
            const tReal& mu2=(*iMu);iMu++;
            
            const tReal& B0=(*iB);iB++;
            const tReal& B1=(*iB);iB++;
            const tReal& B2=(*iB);iB++;
            
            sMuB=mu0*B0+mu1*B1+mu2*B2;
            sMuMu=mu0*mu0+mu1*mu1+mu2*mu2;
            (*iF)= mAlpha*((mu1 * B2 - mu2 * B1) + mBeta * (mu0 * sMuB - B0 * sMuMu));iF++;
            (*iF)= mAlpha*((mu2 * B0 - mu0 * B2) + mBeta * (mu1 * sMuB - B1 * sMuMu));iF++;
            (*iF)= mAlpha*((mu0 * B1 - mu1 * B0) + mBeta * (mu2 * sMuB - B2 * sMuMu));iF++;
            
            
        }
 
          
        
    }
    inline void computeNLLFunction(const tIndex& nParticles,const tDimension& dim,
                                   const tReal *mu,const tReal *B,tReal *F) const {
 
        ASSERT_IN(dim==3);
        
        //iterator on point
        tIndex p;
 
        //sMuB=<Mu,B>
        //sMuMu=<Mu,Mu>
        tReal sMuB;
        //iterator on mu
        const tReal *iMu=mu;
        //iterator on B
        const tReal *iB=B;
        //iterator on F
        tReal *iF=F;
        
        for (p=0;p<nParticles;p++) {//loop on point
            
         
            // A = alpha(  mu \wedge B + beta ( <\mu,B> \mu -  <\mu,\mu> B ) )
            const tReal& mu0=(*iMu);iMu++;
            const tReal& mu1=(*iMu);iMu++;
            const tReal& mu2=(*iMu);iMu++;
            
            const tReal& B0=(*iB);iB++;
            const tReal& B1=(*iB);iB++;
            const tReal& B2=(*iB);iB++;
            
            sMuB=mu0*B0+mu1*B1+mu2*B2;
            //sMuMu=mu0*mu0+mu1*mu1+mu2*mu2;
            //sMuMu=1
            (*iF)= mAlpha*((mu1 * B2 - mu2 * B1) + mBeta * (mu0 * sMuB - B0 ));iF++;
            (*iF)= mAlpha*((mu2 * B0 - mu0 * B2) + mBeta * (mu1 * sMuB - B1 ));iF++;
            (*iF)= mAlpha*((mu0 * B1 - mu1 * B0) + mBeta * (mu2 * sMuB - B2 ));iF++;
            
            
        }
 
          
        
    }
 
public:
    
    virtual tString toString() const override {
        return (mIsMuNormalized)?
            "F(M,B)="+std::to_string(mAlpha)+".( M ^ B + "+std::to_string(mBeta)+"<M,B>M - B )\n":
            "F(M,B)="+std::to_string(mAlpha)+".( M ^ B + "+std::to_string(mBeta)+"<M,B>M - |M|^2 B )\n";
    }
 
 
};
 
#endif