SM_MonteCarloSystem.h

#ifndef SM_MonteCarloSystem_H
#define SM_MonteCarloSystem_H
 
//base class
#include "SM_System.h"
 
 
//stochastic output data header
#include "SM_StochasticOutput.h"
 
//stochastic function
#include "SM_MultiStochasticFunctions.h"
 
//network
#include "SM_Network.h"
 
//material
#include "SM_Material.h"
 
//operator
#include "SM_Operator.h"
 
 
//array manipulating
#include <valarray>
 
class SM_MonteCarloSystem : public SM_System {
   
    //attributes
private :
 
    typedef SM_MonteCarloSystem Self;
    typedef SM_System SuperClass;
 
   
    //mAlpha=\frac{\bar E}{k_B.T}
    tReal mAlpha;
    //mSigma=\frac{2}{25}*\left( \frac{T*k_B}{\mu_B} \right))^{\frac{1}{5}}
    tReal mSigma;
 
    //statistics
    tIndex mRejectsNumber;
    tIndex mMovesNumber;
  
    
protected:
    // CONSTRUCTORS 
    SM_MonteCarloSystem(void) {
        mAlpha=0;
        mSigma=0;
        mRejectsNumber=0;
        mMovesNumber=0;
    }
    
    // DESTRUCTORS 
    virtual ~SM_MonteCarloSystem(void) {
    }
 
public : 
 
     
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
      
        return mem;
    }
 
   
 
    virtual void setNoiseTemperature(const tReal& T)  override {
        mAlpha=getMaterial().getCharacteristicEnergy();
        mAlpha/=SM_Constants::K_B;
        mAlpha/=T;
 
        mSigma=0.08L;//(2.L/25.L);
        mSigma*=pow((T*SM_Constants::CK_B)/SM_Constants::CMU_B,0.2L);
 
        
        SM_System::setNoiseTemperature(T);
    }
 
    inline const tReal& getNoiseRate() const {
        return mSigma;
    }
    inline const tReal& getEnergyScaling() const {
        return mAlpha;
    }
   
    inline const tIndex& getRejectsNumber() const {
        return mRejectsNumber;
    }
   
    inline const tIndex& getMovesNumber() const {
        return mMovesNumber;
    }
    
protected:
    inline  tIndex& getMovesNumber() {
        return mMovesNumber;
    }
    
    inline tIndex& getRejectsNumber() {
        return mRejectsNumber;
    }
    
    //computational methods
    //=====================
   
public:
  
 
    
    virtual void normalize(const tBoolean& isAdimensionized) override {
        SuperClass::normalize(isAdimensionized);
    }
    
 
    virtual void discretize() override {
        
        SuperClass::discretize();
          
        mRejectsNumber=0;
        mMovesNumber=0;
        
        
    }
 
    //simulation methods
    //===================
 
    virtual tULLInt getGeneratedRandomNumbers() const override {
 
        //random particles number + random move type + SM_Constants::DIM x random coordinates + random for p
        tULLInt nRNGPerCore=3+SM_Constants::DIM;
        nRNGPerCore*=getNetwork().getParticlesNumber();
        return nRNGPerCore;
    }
 
 
    
    template<class StochOutputImplement>
    inline tBoolean deterministicRun(const tIndex& steppersNumber,SM_StochasticOutput<StochOutputImplement>& data) {
        std::cout<<"No deterministic running method for Monte Carlo system \n";
        return false;
    }
    
    tBoolean stochasticRun(const tIndex& steppersNumber,
                           SM_MultiStochasticFunctionsInterface& sfs);
    
    template<class StochOutputImplement>
    tBoolean stochasticRun(const tIndex& steppersNumber,
                           SM_MultiStochasticFunctionsInterface& sfs,
                           SM_StochasticOutput<StochOutputImplement>& statistics);
    
    
    template<class StochFunctionsImplement>
    tBoolean stochasticRunWithSCStochasticFunctions(const tIndex& steppersNumber,
                                                    SM_MultiStochasticFunctions<StochFunctionsImplement>& sfs);
    template<class StochFunctionsImplement,class StochOutputImplement>
    inline tBoolean stochasticRunWithSCStochasticFunctions(const tIndex& steppersNumber,
                                                           SM_MultiStochasticFunctions<StochFunctionsImplement>& sfs,
                                                           SM_StochasticOutput<StochOutputImplement>& statistics);
 
    
 
protected:        
 
    virtual void updateStateForNextStep(SM_RealField& St)=0;
    
    void MCStep(SM_MultiStochasticFunctionsInterface& multiStochasticFunctions,
                const SM_Material& material,const SM_Network& network,
                SM_RealField& S,
                const tIndex& stepIndex,const tReal& alpha,const tReal& sigma,
                tIndex& nMoves,tIndex& nRejects);
    
    template<class StochFunctionsImplement>
    inline void MCStepWithSCStochasticFunctions(SM_MultiStochasticFunctions<StochFunctionsImplement>& multiStochasticFunctions,
                                                const SM_Material& material,const SM_Network& network,
                                                SM_RealField& S,
                                                const tIndex& stepIndex,const tReal& alpha,const tReal& sigma,
                                                tIndex& nMoves,tIndex& nRejects);
   
    template<class StochFunctionsImplement>
    inline void randomTrialMoveWithSCStochasticFunctions(SM_StochasticFunctions<StochFunctionsImplement>& stochasticFunctions,
                                                         const tReal& sigma,
                                                         tReal *bS,const tReal* eS) const;
    
    void randomTrialMove(SM_StochasticFunctionsInterface& stochasticFunctions,
                         const tReal& sigma,
                         tReal *bS,const tReal* eS) const ;
    
public:
    virtual tString toString() const override;
  
};
 
#include "SM_MonteCarloSystem.hpp"
#endif