SM_TemplatedSystem.h

Go to the documentation of this file.

#ifndef SM_TemplatedSystem_H
#define SM_TemplatedSystem_H
 
#include "SM_System.h"
 
 
#include "SM_ZeemanOperator.h"
#include "SM_DemagnetizedOperator.h"
#include "SM_HeissenbergOperator.h"
 
 
template<class SystemImpl>
class SM_TemplatedSystem : public SM_System {
   
    //attributes
private :
 
 
    //associations
    
  
    const SM_ZeemanOperator *mZeemanOperator;
    const SM_DemagnetizedOperator *mDemagnetizedOperator;
    const SM_HeissenbergOperator *mHeissenbergOperator;
 
  
 
  
    
protected:
    // CONSTRUCTORS 
    SM_TemplatedSystem(void) {
        
        
    }
    
    // DESTRUCTORS 
    virtual ~SM_TemplatedSystem(void) {
    }
 
 
public : 
    // CREATE class
   
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    
    //SET & GET methods
 
   
    virtual void getOperatorNames(std::vector<tString>& names) const override {
        names.clear();
        if (mZeemanOperator!=null) names.push_back(mZeemanOperator->getName());
        if (mDemagnetizedOperator!=null) names.push_back(mDemagnetizedOperator->getName());
        if (mHeissenbergOperator!=null) names.push_back(mHeissenbergOperator->getName());
        
    }
 
 
public:
  
    virtual void discretize() {
 
        SM_System::discretize();
        
        //discretize the operators on the network
      
        //registed the operatosr for the  templated method computeTemplatedMagneticField call
            
        mZeemanOperator=dynamic_cast<const SM_ZeemanOperator*>(getOperator("Zeeman"));
        mDemagnetizedOperator=dynamic_cast<const SM_DemagnetizedOperator*>(getOperator("Demagnetized"));
        mHeissenbergOperator=dynamic_cast<const SM_HeissenbergOperator*>(getOperator("Heissenberg"));
        
        
    }
    
 
 
public:
   
    template<class StochImpl>
    tBoolean  makeTemplatedRelaxation(const SM_TemplatedStochasticFunction<StochImpl>& randomFunction,
                                      tReal *mu,tReal *Es) {
        std::cerr<<"SM_templatedSystem:::makeTemplatedRelaxation(randomFunction,mu,Es) is not yet implemented ! \n";
        return false;
    }
  
    
public:
    template<class StochImpl,class NoiseImpl>
    tBoolean  makeTemplatedRelaxation(const SM_TemplatedStochasticFunction<StochImpl>& randomFunction,
                                   const SM_TemplatedNoiseRateFunction<NoiseImpl>& noiseRateFunction,
                                      tReal *mu,
                                      tReal *Es);
    
protected:
    inline void computeTemplatedMagneticField(const tIndex& t,
                                              const SM_Network& network,
                                              const tReal *mu,
                                              tReal *B) const {
        
        // B=0
        memset(B,0,sizeof(tReal)*network.getParticlesNumber()*network.getDimension());
        
        //B+=Bop
        if (mZeemanOperator!=null)
            mZeemanOperator->computeTemplatedMagneticField(t,network,mu,B);
        if (mDemagnetizedOperator!=null)
            mDemagnetizedOperator->computeTemplatedMagneticField(t,network,mu,B);
        if (mHeissenbergOperator!=null)
            mHeissenbergOperator->computeTemplatedMagneticField(t,network,mu,B);
    }
    
    inline void computeTemplatedMagneticFieldAndEnergies(const tIndex& t,
                                                         const SM_Network& network,
                                                       const tReal *mu,
                                                       tReal *B,tReal* Es) const {
        
        // B=0
        memset(B,0,sizeof(tReal)*network.getParticlesNumber()*network.getDimension());
 
        //total energy
        tReal &Et=(*Es);Es++;//total energy
        tReal *Es_p=Es;//energy of the operator op
        //B+=Bop
        if (mZeemanOperator!=null) {
            mZeemanOperator->computeTemplatedMagneticFieldAndEnergy(t,network,mu,B,(*Es_p));
            Et+=(*Es_p);//operator's energy contribution
            Es_p++;//energy of next operator
        }
        if (mDemagnetizedOperator!=null) {
            mDemagnetizedOperator->computeTemplatedMagneticFieldAndEnergy(t,network,mu,B,(*Es_p));
            Et+=(*Es_p);//operator's energy contribution
            Es_p++;//energy of next operator
        }
        if (mHeissenbergOperator!=null) {
            mHeissenbergOperator->computeTemplatedMagneticFieldAndEnergy(t,network,mu,B,(*Es_p));
            Et+=(*Es_p);//operator's energy contribution
            Es_p++;//energy of next operator
        }
    }
   virtual  tBoolean computeMuAtNextTimeStep(const tReal& dt,const tReal& epsilon_t,
                                         const tIndex& nParticles,const tDimension& dim,
                                         const tReal* mu_t,
                                         tReal *mu_tpdt)  const {
       return computeTemplatedMuAtNextTimeStep(dt,epsilon_t,nParticles,dim,mu_t,mu_tpdt);
   }
    inline tBoolean computeTemplatedMuAtNextTimeStep(const tReal& dt,const tReal& epsilon_t,
                                                 const tIndex& nParticles,const tDimension& dim,
                                                 const tReal* mu_t,
                                                 tReal *mu_tpdt)  const {
        
        return static_cast<const SystemImpl*>(this)->computeTemplatedMuAtNextTimeStep(dt,epsilon_t,nParticles,dim,mu_t,mu_tpdt);
    }
    
};
 
#include "SM_TemplatedSystem.hpp"
#endif