SM_HeissenbergOperator.h

Go to the documentation of this file.

#ifndef SM_HeissenbergOperator_H
#define SM_HeissenbergOperator_H
 
//base classes
#include "SM_TemplatedOperator.h"
 
//network class
#include "SM_Network.h"
 
class SM_HeissenbergOperator : public SM_TemplatedOperator<SM_HeissenbergOperator> {
    
    //attributes
private :
    
    
    //association
  
  
   
protected:
    // CONSTRUCTORS 
    SM_HeissenbergOperator(void) {
        setName("Heissenberg");
    }
    
    // DESTRUCTORS 
    virtual ~SM_HeissenbergOperator(void) {
    }
    
public : 
 
    //Instance building
    //=================
 
    inline static CORE_UniquePointer<SM_HeissenbergOperator> New() {
        return CORE_UniquePointer<SM_HeissenbergOperator>(new SM_HeissenbergOperator(),SM_HeissenbergOperator::Delete());
    }
    
    virtual CORE_UniquePointer<SM_Operator> NewInstance() const override {
        return New();
    }
public:
 
     //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
   
    virtual void computeMagneticField(const tIndex& t,
                                      const SM_Network& network,
                                      const tReal *mu,
                                      tReal *B) const override {
        return computeTemplatedMagneticField(t,network,mu,B);
    }
    virtual void computeMagneticFieldAndEnergy(const tIndex& t,
                                               const SM_Network& network,
                                               const tReal *mu,
                                               tReal *B,
                                               tReal& E) const override{
        return computeTemplatedMagneticFieldAndEnergy(t,network,mu,B,E);
    }
    inline void computeTemplatedMagneticField(const tIndex& t,
                                              const SM_Network& network,
                                              const tReal *mu,
                                              tReal *B) const {
        
        tReal E=0;
        computeTemplatedMagneticFieldAndEnergy(t,network,mu,B,E);
    }
 
    inline void computeTemplatedMagneticFieldAndEnergy(const tIndex& t,
                                                       const SM_Network& network,
                                                       const tReal *mu,
                                                       tReal *H,
                                                       tReal& E) const {
         //get the number of particles of the network
        const tIndex& nParticles=network.getParticlesNumber();
 
        //get the dimension of the netwok
        const tDimension& dim=network.getDimension();
 
        //strength of the network
        const tReal& lambda=network.getLambda();
        tReal iLambda2x2=2./(lambda*lambda);
 
        //iterator on particles
        tIndex i,j;
        
        //iterator on dimension
        tDimension d;
        
        //Bid at first particles
        tReal *Hi=H;
        tReal *Hi_d=null;
 
        //d-coordinate of magnetic moment at particle j
        const tReal *Muj_d;
 
        //d-coordinate of magnetic moment at particle i
        const tReal *Mui=mu,*Mui_d=null;
 
        
        const tUInt  *nNeighbors_i=&network.getNeighborsNumber()[0];//number of neighbor of the particle 0
        const tIndex *iNeighbors=&network.getNeighborsIndices()[0];//first index of the neighbor of the particle 0
        
        const tReal *iJ=&network.getHeissenbergCoefficients()[0];//value of the exchange of the neighbor of particles i
       
        tUInt iN;//iterator on neighbor particles
 
        //for (i=0;i<nParticles;i++) std::cout<<"\t mu["<<i<<"]=("<<mu[i*dim]<<","<<mu[i*dim+1]<<","<<mu[i*dim+2]<<")\n";
 
        //Energy
       
        E=0;
 
        tReal Hex_id;//d-coordinate of Hexchange at particle Pi
        for (i=0;i<nParticles;i++) {//loop on particles
            
            //loop on the neighbors of the particle i
 
          
            for (iN=0;iN<(*nNeighbors_i);iN++) {
              
                
                //mu at j of the neighbor particles
                j=(*iNeighbors);
 
               
                //d-coordinate of u at point P_j
                Muj_d=&mu[j*dim];
                
                //Hi +=\sum_j (2.Jij/\lambda^2).  mu_j
                Hi_d=Hi;
                Mui_d=Mui;
                for (d=0;d<dim;d++) {
                    
                    //Hexc =\sum_j (2.Jij/\lambda^2).  mu_j
                    Hex_id=(*Muj_d)*(*iJ)*iLambda2x2;
 
                    //add to d-coordinate of B at particle P_i
                    (*Hi_d)+=Hex_id;
 
                    //E=-0.5<H,mu>
                    E-=0.5*Hex_id*(*Mui_d);
                    
 
                    //next coordinate
                    Hi_d++; //next coordinate of H  at particle Pi
                    Muj_d++;//next coordinate of Mu at particle Pj
                    Mui_d++;//next coordinate of Mu at particle Pi
                }
 
              
                
                //next neighbor particle
                iNeighbors++;
                iJ++;
               
            }//end loop on neighbors
            
         
            //neighbors number of next particle
            nNeighbors_i++;
 
            //H at next particle
            Hi+=dim;
            //Mu at next particle
            Mui+=dim;
         
            
        }//end loop on particles
        
     }//end method
    virtual  tReal computeEnergy(const tIndex &t,
                                 const SM_Network& network,
                                 const tReal *mu) const override{
        return computeTemplatedEnergy(t,network,mu);
    }
    inline tReal computeTemplatedEnergy(const tIndex& t,
                                        const SM_Network& network,
                                        const tReal *mu) const {
        
         //get the number of particles of the network
        const tIndex& nParticles=network.getParticlesNumber();
 
        //get the dimension of the netwok
        const tDimension& dim=network.getDimension();
 
        //strength of the network
        const tReal& lambda=network.getLambda();
        tReal iLambda2=1./(lambda*lambda);
 
        //iterator on particles
        tIndex i,j;
        
        //iterator on dimension
        tDimension d;
 
        //Mu at particle i
        const tReal *Mui=mu,*Mui_d;
 
        //Mu at particle j
        const tReal *Muj_d;
 
        //neighbors
        const tUInt  *nNeighbors_i=&network.getNeighborsNumber()[0];//number of neighbor of the particle 0
        const tIndex *iNeighbors=&network.getNeighborsIndices()[0];//first index of the neighbor of the particle 0
        
        const tReal *iJ=&network.getHeissenbergCoefficients()[0];//value of the exchange of the neighbor of particles i
     
        
        tUInt iN;//iterator on neighbor particles
 
        
        //energy
        tReal E=0;
        
        for (i=0;i<nParticles;i++) {//loop on particles
            
            //loop on the neighbors of the particle i
         
            for (iN=0;iN<(*nNeighbors_i);iN++) {
                
                //index of the neighbor particle
                j=(*iNeighbors);
                
                //mu at j
                Muj_d=&mu[j*dim];
                
                //E -=(1/\lambda^2) \sum_j (Jij/\lambda^2).  <mu_j,mu_i>
                Mui_d=Mui;
                for (d=0;d<dim;d++) {
                    E-=(*Muj_d)*(*Mui_d)*(*iJ)*iLambda2;
                    Mui_d++;
                    Muj_d++;
                }
                
                //next neighbor particle
                iNeighbors++;
                //next J of neihbor relation
                iJ++;
            
            }//end loop on neighbors
            
        
            //neighbors number of next particle i
            nNeighbors_i++;
 
            //magnetic moment at next particle i
            Mui+=dim;
         
            
        }//end loop on particles i
 
      
        
        return E;
    }//end method
    
    
};
 
 
#endif