SM_TemplatedSystem.hpp

Go to the documentation of this file.

#ifndef SM_TemplatedSystem_HPP
#define SM_TemplatedSystem_HPP
template<class SystemImpl>
template<class StochImpl,class NoiseImpl>
tBoolean  SM_TemplatedSystem<SystemImpl>::makeTemplatedRelaxation(const SM_TemplatedStochasticFunction<StochImpl>& randomFunction,
                                                                  const SM_TemplatedNoiseRateFunction<NoiseImpl>& noiseRateFunction,
                                                                  tReal *mu,tReal *E) {
    //return value
    tBoolean succeeds=true;
    
    
    //network of the system
    const SM_Network& network=this->getNetwork();
 
    //dimension of th enetwork
    const tUSInt& dim=network.getDimension();
 
    //number of particles
    const tIndex& nParticles=network.getParticlesNumber();
    
    //field array size & iterator on it
    tIndex i,N=nParticles*dim;
 
    //time stepper
    const SM_TimeStepper& timeStepper=this->getTimeStepper();
 
    //time step
    const tReal& dt=timeStepper.getTimeStep();
 
    //maximum time steps number
    const tIndex &nTimeSteps=timeStepper.getMaximumTimeStepsNumber();
    
    //magnetic moment at t=0
    const SM_RealField & mu0=this->getInitialMagneticMoment();
    
 
    //input assertions
    ASSERT_IN(mu0.getElementsNumber()==nParticles);
    ASSERT_IN(getMagneticField().getElementsNumber()==nParticles);
 
    //magnetic field B
    tReal *B=&getMagneticField()[0];
    
    //current time
    tReal time=0;
    
    
    //noise rate
    tReal epsilon_t;
 
 
   //iterator on mu(t)
    tReal *mu_t=mu;
 
    //initialize mu(t=0)=mu0
    memcpy(mu_t,&mu0[0],N*sizeof(tReal));
 
    //mu at time t+dt
    tReal *mu_tpdt=&mu[N];
    
    //iterator on E(t)
    //size of E is (nOperators+1) x nTimesSteps
    tIndex nE=getOperatorsNumber()+1;
    tReal *E_t=E;
   
    
    //initialize energy to 0
    memset(E,0,nE*nTimeSteps*sizeof(tReal));
    
    
    //LL Function
    const SM_LandauLifschitzFunction& llFunction=getLandauLifschitzFunction(); 
 
    //iterator on B
    tReal *Bi;
 
  
 
    for (tIndex iT=0;iT<nTimeSteps;iT++) {//loop on time
 
        //compute the noise rate by a templated function
        epsilon_t=noiseRateFunction.computeTemplatedFunction(time);
        //compute the noise rate by a virtual function
        //epsilon_t=noiseRateFunction.computeFunction(time);
 
        //compute B
        //std::cout<<"t="<<time<<" ";
        //templated method implemntation:
        computeTemplatedMagneticFieldAndEnergies(iT,network,mu_t,B,E_t);
        //virtual method implementation:
        //computeMagneticField(network,mu_t,B);
        
        //B=dt.B+epsilon_t . sqrt(dt). N(0,1)
        Bi=B;
        for (i=0;i<N;i++) {
            (*Bi) =(*Bi)*dt+epsilon_t*sqrt(dt)*randomFunction.templatedRandom();//templated function called
            //(*Bi) =(*Bi)*dt+epsilon_t*sqrt(dt)*randomFunction.random();//virtual function called
            Bi++;
        }
 
        //compute the landau lifchitz function mu_{t+dt}=LL(mu_t,B)
        llFunction.computeFunction(nParticles,dim,mu_t,B,mu_tpdt);
        
        //compute mu at next time step
        if (!computeTemplatedMuAtNextTimeStep(dt,epsilon_t,nParticles,dim,mu_t,mu_tpdt)) {
            //the algorithm diverges
            //break the loop
            succeeds=false;
            break;
        }
        
        //next time step
        time+=dt;//time at next time step
        mu_t+=N;//mu at t+dt
        mu_tpdt+=N;//mu at t+dt+dt
        E_t+=nE;//energy at next time step
    }
 
    return succeeds;
}
 
    
 
#endif