SM_AnisotropyOperator.h

#ifndef SM_AnisotropyOperator_H
#define SM_AnisotropyOperator_H
 
//base classes
#include "SM_SliceOperator.h"
 
//network class
#include "SM_Network.h"
 
//array utilities
#include "functions_array.h"
 
template<class I>
class SM_AnisotropyOperator : public SM_SliceOperator {
    
    //attributes
private :
    
   
   
protected:
    // CONSTRUCTORS 
    SM_AnisotropyOperator(void) {
    }
    
    
    // DESTRUCTORS 
    virtual ~SM_AnisotropyOperator(void) {
    }
    
public : 
 
    //Instance building
    //=================
 
public:
 
     //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    
    //Fields computation
    //==================
  
    virtual void computeMagneticFieldSlice(const tIndex& stepIndex,
                                           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& stepIndex,
                                    const SM_Network& network,
                                    const SM_Material& material,
                                    const SM_RealField& S) const final {
         //begin ietratro oanisotropy direction
        const tReal *U=&material.getAnisotropyDirections()[0];
        
        //end anisotropy direction
        const tReal *eU=U;
        eU+=material.getAnisotropyDirections().size();
        
        tReal Ei,W;
        const tReal *iS=&S[i*SM_Constants::DIM];
        const tReal *eS=iS;eS+=SM_Constants::DIM;
        computeSpinEnergy(material.getAdimensionizedAnisotropyEnergyFactor(),U,eU,
                          iS,eS,Ei,W);
        return Ei;
                      
    }
 
    
    inline void computeSpinEnergy(const tReal &K,const tReal *iU,const tReal *eU,
                                  const tReal *iS,const tReal* eS,
                                  tReal& Ei,tReal& W)  const  {
        
      
        computePhi(iU,eU,iS,eS,Ei,W);
        Ei*=K;    
    }
  
    
    
    //Total energy computation
    //========================
  
  
 
    virtual  tReal computeEnergySlice(const tIndex& timeIndex,
                                      const SM_Network& network,
                                      const SM_Material& material,
                                      const tIndex& startIndex,
                                      const tIndex& endIndex,
                                      const tReal *S) const;
    
    
    
    //general anisotropy expression
    //=============================
    
    inline void computePhi(const tReal *U,const tReal *eU,
                           const tReal*S,const tReal *eS,
                           tReal& phi,tReal& W) const {
        return static_cast<const I*>(this)->computePhi(U,eU,S,eS,phi,W);
    }
 
    inline void  computePhiDerivatives(const tReal *U,const tReal *eU,
                                       const tReal*S,const tReal* eS,
                                       tReal& phi,std::array<tReal,SM_Constants::DIM>& gradPhi,
                                       tReal& W,tReal& W3) const {
        return static_cast<const I*>(this)->computePhiDerivatives(U,eU,S,eS,phi,gradPhi,W,W3);
    }
    
};
 
#include "SM_AnisotropyOperator.hpp"
#endif