SM_System.h

Go to the documentation of this file.

#ifndef SM_System_H
#define SM_System_H
 
//base class
#include "SM_Object.h"
 
//landau lifschtz function
#include "SM_LandauLifschitzFunction.h"
 
//stochastic function
#include "SM_StochasticFunction.h"
 
//network
#include "SM_Network.h"
 
//time
#include "SM_TimeStepper.h"
 
//operator
#include "SM_Operator.h"
//noise header
#include "SM_NoiseRateFunction.h"
#include "SM_InverseNoiseRateFunction.h"
#include "SM_ConstantNoiseRateFunction.h"
 
//array manipulating
#include <valarray>
 
class SM_System : public SM_Object {
   
    //attributes
private :
 
 
    //associations
    
 
    //the landau lishitz function
    SM_LandauLifschitzFunction mLLFunction;
 
    //network
    SM_Network mNetwork;
 
    //time stepper
    SM_TimeStepper mTimeStepper;
 
    //operators
    std::map<tString,CORE_UniquePointer<SM_Operator>> mOperators;   
   
 
    //total magnetic field of the system
    SM_RealField mB;
 
    //initial mu of size mParticlesNumber x mDimension
    SM_RealField mMu0;
       
    //the noise rate function
    CORE_UniquePointer<SM_NoiseRateFunction> mNoiseRateFunction;
 
 
  
   
    
protected:
    // CONSTRUCTORS 
    SM_System(void) {
        
          
        
        tReal alpha=-1;
        tReal beta=2;
        
        mLLFunction.setAlpha(alpha);
        mLLFunction.setBeta(beta);
        
        mMu0={0,1,0};
    }
    
    // DESTRUCTORS 
    virtual ~SM_System(void) {
    }
 
 
public : 
 
     
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+=mLLFunction.getContentsMemorySize();
        mem+=mNetwork.getContentsMemorySize();
        mem+=mNetwork.getContentsMemorySize();
        mem+=mB.getContentsMemorySize();
        mem+=mMu0.getContentsMemorySize();
        mem+=(mNoiseRateFunction.get()==null)?0:mNoiseRateFunction->getMemorySize();
        std::for_each(mOperators.cbegin(),mOperators.cend(),
                      [&](const auto& op) {
                          mem+=op.first.size();
                          mem+=op.second->getMemorySize();
                      });
        return mem;
    }
    
    //SET & GET methods
 
    
    //Network data
    //=============
public:
    inline const SM_Network& getNetwork() const {
        return mNetwork;
    }
    inline SM_Network& getNetwork() {
        return mNetwork;
    }
 
    //time stepper data
    //=================
    inline const SM_TimeStepper& getTimeStepper() const {
        return mTimeStepper;
    }
    inline SM_TimeStepper& getTimeStepper() {
        return mTimeStepper;
    }
 
    //magnetic moment data
    //====================
 
public:
    
    inline void setInitialMagneticMoment(const std::valarray<tReal>& mu0)  {
        mMu0=mu0;
        mMu0.normalize();
    }
  
    inline void setInitialMagneticMoment(const SM_RealField& mu0)  {
        mMu0=mu0;
        mMu0.normalize();
    }
    
    inline void setInitialMagneticMoment(const tIndex& N,const std::array<tReal,3>& mu0)  {
        mMu0.setElementsNumber(N);
        mMu0.initialize(mu0);
    }
     
   
    inline const SM_RealField& getInitialMagneticMoment()  const {
        return mMu0;
    }
 
     
   
 
    //stochastic function
    //===================
     
    inline void setNoiseRateFunction(CORE_UniquePointer<SM_NoiseRateFunction>& f) {
        mNoiseRateFunction=std::move(f);
    }
    
    
    inline SM_NoiseRateFunction& getNoiseRateFunction() {
        return *mNoiseRateFunction.get();
    }
    inline const SM_NoiseRateFunction& getNoiseRateFunction() const {
        return *mNoiseRateFunction.get();
    }
 
 
    //Landau lifschtz function
    //========================
    
    inline const SM_LandauLifschitzFunction& getLandauLifschitzFunction() const {
        return mLLFunction;
        
    }
    inline SM_LandauLifschitzFunction& getLandauLifschitzFunction() {
        return mLLFunction;
        
    }
 
    //operators
    //==========
    
    inline void addOperator(CORE_UniquePointer<SM_Operator> op) {
        if (op.get()!=null) mOperators[op->getName()]=std::move(op);
    }
    
    inline const SM_Operator* getOperator(const tString& name) const {
        auto op=mOperators.find(name);
        if (op!=mOperators.end()) {
            return op->second.get();
        }
        return null;
    }
 
    inline void copyOperators(const SM_System& system) {
        const std::map<tString,CORE_UniquePointer<SM_Operator>>&  operators=system.getOperators();
        CORE_UniquePointer<SM_Operator> cop;
        for_each(operators.begin(),operators.end(),
                 [&](const auto& op) {
                     cop=op.second->NewInstance();
                     cop->copy(*op.second.get());
                     mOperators[op.first]=std::move(cop);
                 });
    }
    const std::map<tString,CORE_UniquePointer<SM_Operator>>& getOperators() const {
        return mOperators;
    }
        inline tIndex getOperatorsNumber() const {
            return mOperators.size();
        }
        virtual void getOperatorNames(std::vector<tString>& names) const {
            names.clear();
            for(const auto& op : mOperators) {
                names.push_back(op.first);
            }
        
        }
 
  
   
    public:
  
  
 
 
    public:
 
        //simulation methods
        //===================
    protected:
        inline SM_RealField& getMagneticField() {
            return mB;
        }
 
    public:
        virtual void discretize() {
 
            //get the network data
            const SM_Network& network=getNetwork();
 
            //discretize magnetic field
            mB.setElementsNumber(network.getParticlesNumber());
        
            //discretize the operators on the network
            for(auto& op : mOperators) {
                op.second->discretize(*this);
            }
        
        }
    
  
        tBoolean makeRelaxation(const SM_StochasticFunction* randomFunction,tReal *mu,tReal *Es);
  
    
    protected:
        inline void computeMagneticField(const tIndex& t,
                                         const SM_Network& network,
                                         const tReal *mu,
                                         tReal *B) const {
        
            tIndex N=network.getParticlesNumber()*network.getDimension();
        
            // B=0
            memset(B,0,sizeof(tReal)*N);
        
            //B+=Bop
            for(const auto& op : mOperators) {
                op.second->computeMagneticField(t,network,mu,B);
            }
        }
        inline void computeMagneticFieldAndEnergies(const tIndex& t,
                                                    const SM_Network& network,
                                                    const tReal *mu,
                                                    tReal *B,
                                                    tReal *Es) const {
        
            tIndex N=network.getParticlesNumber()*network.getDimension();
        
            // B=0
            memset(B,0,sizeof(tReal)*N);
        
            //B+=Bop
            tReal &Et=(*Es);Es++;//total energy
            Et=0;//initialize total energy
            tReal *Es_p=Es;//energy of the operator op
            for(const auto& op : mOperators) {
                op.second->computeMagneticFieldAndEnergy(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=0;
 
    public:
        virtual tString toString() const override;
    };
#endif