SM_DipolarOperator.h

#ifndef SM_DipolarOperator_H
#define SM_DipolarOperator_H
 
//base classes
#include "SM_SliceOperator.h"
#include "SM_LinearSliceOperator.h"
 
//network class
#include "SM_Network.h"
 
 
//dipolar field class
#include "SM_DipolarField.h"
 
class SM_DipolarOperator : public SM_SliceOperator, public SM_LinearSliceOperator {
    
  
private :
    
    //type class
    typedef SM_DipolarOperator SelfClass;
    
    typedef SM_SliceOperator SuperClass;
    typedef SM_LinearSliceOperator Interface;
 
    //attributes
    
    //constant for computing H
    tReal mLambdaH;
    
protected:
    // CONSTRUCTORS 
    SM_DipolarOperator(void) {
        
        setName("Dipolar");
        mLambdaH=0;
    }
    
    // DESTRUCTORS 
    virtual ~SM_DipolarOperator(void) {
    }
   
    
public : 
 
    //Instance building
    //=================
 
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=Interface::getContentsMemorySize();
        return mem;
    }
public:
 
    
    //discretize the operator
    //=======================
    virtual void discretize(const SM_Network& network,
                            const SM_Material& material) override {
        
        SuperClass::discretize(network,material);
        
        
        
        //x coefficient for H
        //lambdaH=\frac{1}{4.PI}
        mLambdaH=4;
        mLambdaH*=M_PI;
        mLambdaH=1./mLambdaH;
        //mLambdaH*=(mu_0.mu_B)/(A^3) for dimensionzed field
        //        *=1 for adimensionized field
        mLambdaH*=material.getAdimensionizedDerivativeEnergyFactor();//mCde
        mLambdaH*=material.getAdimensionizedDipolarEnergyFactor();//cEdip
       
    }
 
    
protected:
    inline const tReal& getLambdaH() const {
        return mLambdaH;
    }
    
    //Fields computation
    //==================
public:
 
    
  
    
    
    void computeDipolarFieldAtPoints(const SM_Material& material,
                                     const tInteger& nP,//number of particles of the network (P,S)
                                     const tReal *P,//X at particles of the network for each S
                                     const tReal *S,//S at particles of the network
                                     const tInteger& nX,//number of elements of X (number of elements of H)
                                     const tReal* X,//coordinate of points in which H is computed
                                     const tBoolean& alpha,
                                     tReal *H) const;
    
    void computeDipolarFieldAtSeparatedPoints(const SM_Material& material,
                                              const tInteger& nP,//number of particles of the network (P,S)
                                              const tReal *P,//X at particles of the network for each S
                                              const tReal *S,//S at particles of the network
                                              const tInteger& nX,//number of elements of X (number of elements of H)
                                              const tReal* X,//coordinate of points in which H is computed
                                              const tBoolean& alpha,
                                              tReal *H) const;   
    
   
    //Spin energy computation
    //=======================
  
    inline static void ComputeSpinDipolarEnergy(const tReal& mu_s,
                                                const tReal &Edip,
                                                const tInteger& nParticles, const tReal* X,const tReal* S,
                                                const tReal *Xi,const tReal *Si,
                                                tReal& E)  {
        
       
        E=0;
 
        //iterators on first particle j
        const tReal *iXj=X;// coordinates
        const tReal *iSj=S;// spin direction
        
        //iterators on last particle j
        const tReal *eXj=X;eXj+=nParticles*SM_Constants::DIM;
        
        
        //dipolar interaction betaween particle i and particules j in [start,end[
        SM_DipolarField::ComputeUnscaledSpinEnergy(Xi,Si,//coordinate & direction of spin of  particle i
                                                   iXj,eXj,//begin & end iterator on coordinates of particles j
                                                   iSj,//begin iterator on direction of magnetic moment of particles j
                                                   E);//Energy between particle i and particles j
        
      
        E*=Edip;
        E*=mu_s;
        E*=mu_s;
        E/=M_PI;
        E*=0.25;
        
    }
    inline static void ComputeSeparatedSpinDipolarEnergy(const tReal& mu_s,
                                                         const tReal &Edip,
                                                         const tInteger& nParticles, const tReal* X,const tReal* S,
                                                         const tReal *Xi,const tReal *Si,
                                                         tReal& E)  {
        
        
        E=0;
        
        //iterators on first particle j
        const tReal *iXj=X;// coordinates
        const tReal *iSj=S;// spin direction
        
        //iterators on last particle j
        const tReal *eXj=X;eXj+=nParticles*SM_Constants::DIM;
        
        
        //dipolar interaction betaween particle i and particules j in [start,end[
        SM_DipolarField::ComputeSeparatedUnscaledSpinEnergy(Xi,Si,//coordinate & direction of spin of  particle i
                                                            iXj,eXj,//begin & end iterator on coordinates of particles j
                                                            iSj,//begin iterator on direction of magnetic moment of particles j
                                                            E);//Energy between particle i and particles j
        
      
        E*=Edip;
        E*=mu_s;
        E*=mu_s;
        E/=M_PI;
        E*=0.25;
        
    }
  
   
    
};
 
 
#endif