SM_ConstantZeemanOperator.h

#ifndef SM_ConstantZeemanOperator_H
#define SM_ConstantZeemanOperator_H
 
//base classes
#include "SM_ZeemanOperator.h"
 
class SM_ConstantZeemanOperator : public SM_ZeemanOperator {
    
    //attributes
private :
    
    
    //association
 
    //super class type
    typedef SM_ZeemanOperator SuperClass;
    
   
protected:
    // CONSTRUCTORS 
    SM_ConstantZeemanOperator(void) {
        setParticlesNumber(1);
        setTimeStepsNumber(1);
        
    }
    
    // DESTRUCTORS 
    virtual ~SM_ConstantZeemanOperator(void) {
    }
    
public : 
 
    //Instance building
    //=================
 
   
    inline static CORE_UniquePointer<SM_ConstantZeemanOperator> New() {
        return CORE_UniquePointer<SM_ConstantZeemanOperator>(new SM_ConstantZeemanOperator(),
                                                              SM_ConstantZeemanOperator::Delete());
    }
     
    virtual CORE_UniquePointer<SM_SliceOperator> NewInstance() const override {
        return New();
    }
 
      
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
  
    
public:
         
    virtual void discretize(const SM_Network& network, const SM_Material& material) override {
        setParticlesNumber(1);
        setTimeStepsNumber(1);
    }
  
   
   
    
    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
    //===========
 
    virtual tReal computeSpinEnergy(const tIndex& i,
                                    const tIndex& timeIndex,
                                    const SM_Network& network,
                                    const SM_Material& material,
                                    const  SM_RealField& S) const final {
        //begin iterator on direction of magnetic moment of spin i
        const tReal *Si=&S[0];Si+=i*SM_Constants::DIM;
        //end iterator on  direction of magnetic moment of spin i
        const tReal *eSi=Si;eSi+=SM_Constants::DIM;
        //energy of the spin i
        tReal Ei;
        ComputeSpinEnergy(material.getAtomicSpinMoment()/material.getAdimensionizedDerivativeEnergyFactor(),//Mu_s
                          getHextValues(),//Hext
                          Si,eSi,Ei);
        return Ei;
    }
 
    //total energy
    //============
    
    virtual tReal computeEnergySlice(const tIndex& stepIndex,
                                     const SM_Network& network,
                                     const SM_Material& material,
                                     const tIndex& startIndex,
                                     const tIndex& endIndex,
                                     const tReal *S) const  final;
    
  
    
   
};
 
 
#endif