SM_HeisenbergOperator.h

#ifndef SM_HeisenbergOperator_H
#define SM_HeisenbergOperator_H
 
//base classes
#include "SM_SliceOperator.h"
#include "SM_LinearSliceOperator.h"
 
//network class
#include "SM_Network.h"
 
 
class SM_HeisenbergOperator : public SM_SliceOperator, public SM_LinearSliceOperator  {
    
    //attributes
private :
    
    
    //association
  
  
   
protected:
    // CONSTRUCTORS 
    SM_HeisenbergOperator(void); 
    
    // DESTRUCTORS 
    virtual ~SM_HeisenbergOperator(void);
    
public : 
 
    //Instance building
    //=================
 
    inline static CORE_UniquePointer<SM_HeisenbergOperator> New() {
        return CORE_UniquePointer<SM_HeisenbergOperator>(new SM_HeisenbergOperator(),SM_HeisenbergOperator::Delete());
    }
    
    virtual CORE_UniquePointer<SM_SliceOperator> NewInstance() const override {
        return New();
    }
public:
 
     //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    
    //Fields computation
    //==================
  
    virtual void computeMagneticFieldSlice(const tIndex& timeIndex,
                                           const SM_Network& network,
                                           const SM_Material& material,
                                           const tIndex& startIndex,
                                           const tIndex& endIndex,
                                           const tReal *S,
                                           const tBoolean& alpha,
                                           const tIndex& nH,
                                           tReal *H) const;
    
    
    //Spin energy computation
    //=======================
    
    virtual tReal computeSpinEnergy(const tIndex& i,
                                    const tIndex& timeIndex,
                                    const SM_Network& network,
                                    const SM_Material& material,
                                    const SM_RealField& S) const final;
  
    inline static void ComputeSpinEnergy(const tIndex& nNeighbors,
                                         const tIndex* neighboringParticles,
                                         const tReal* vJ,const tBoolean& incJ,
                                         const tReal* S,
                                         const tReal* Si,
                                         tReal& Ei)    {
 
        Ei=0;
        
        //end iterator on index of neighbors
        const tIndex *eNeighbors=neighboringParticles;
        eNeighbors+=nNeighbors;
        
        //loop on neighbors
        while (neighboringParticles!=eNeighbors) {
 
 
            //Ei=\sum_j Jij.<Si,Sj>
            Ei+=(*vJ)*functions_array::scalarProduct<tReal,SM_Constants::DIM>(Si,
                                                                              &S[(*neighboringParticles)*SM_Constants::DIM]);
          
            
            //next neighbor
            neighboringParticles++;
            vJ+=incJ;
        }
 
 
        Ei*=-1;
       
    }
    
    //Total energy computation
    //========================
public:
 
    virtual  tReal computeEnergySlice(const tIndex& timeIndex,
                                      const SM_Network& network,
                                      const SM_Material& material,
                                      const tIndex& startIndex,
                                      const tIndex& endIndex,
                                      const tReal *S) const;
    
    
    
    
};
 
 
#endif