SM_LandauLifschitzSystem.hpp

 
//deterministic case
//==================
 
    
template<class StochOutputI>
tBoolean  SM_LandauLifschitzSystem::deterministicRun(const tIndex& steppersNumber,
                                                     SM_StochasticOutput<StochOutputI>& stochasticOutput) {
    tString routineName="SM_LandauLifschitzSystem::deterministicRun<StochasticOutput>(const tIndex&,StochasticOutput&)";
    CORE_Profiler::StartCallRoutine(routineName);
 
    //std::cout<<"begin "<<routineName<<" \n";
    
    //number of drawn for stochastic output 
    const tInteger& nDrawnSteps=stochasticOutput.getDrawnStepsNumber();
    
    //return value
    tBoolean succeeds=true;
    
    //network of the system
    const SM_Network& network=this->getNetwork();
 
    //material of the system
    const SM_Material& material=this->getMaterial();
 
    //number of particles
    const tIndex& nParticles=network.getParticlesNumber();
 
 
    //get direction of magnetic moments
    SM_RealField& St=this->getMagneticMomentDirections();
 
    //std::cout<<"S at time index 0:"<<St<<"\n";
   
#ifdef DEBUG
    if (St.isNANContained()) {
        throw CORE_Exception("stochmagnet/LL",
                             "SM_LLSystem::deterministicRun("+std::to_string(steppersNumber)+",...)",
                             "S0 is nan");
    }
    //std::cout<<"NAN debug verification done.\n";
#endif
   
    //get the variation of the direction of the magnetic moment
    SM_RealField& DeltaSt=this->getMagneticMomentDirectionsVariation();
    
    //magnetic field 
    SM_RealField &Ht=this->getMagneticField();
    
    
    //time stepper
    const SM_TimeStepper& timeStepper=this->getTimeStepper();
    
    //time step
    const tReal& dt=timeStepper.getTimeStep();
 
 
    //index of time
    tIndex& timeIndex=this->getTimeIndex();  
    
    //current time
    tReal &time=this->getTime();
    time=dt;
    time*=timeIndex;
 
    
    //LL Function
    const SM_LandauLifschitzFunction& llFunction=this->getLandauLifschitzFunction();
   
 
    //use relaxation mIsRelaxed=true
    tBoolean isRelaxationReached=false;
    tReal& relaxationValue=getRelaxationValue();
    relaxationValue=0;
    
    
    tInteger iDrawnStep=0;
  
    //do the loop until:
    // time >targetTime
    // or 
    // mIsRelaxed is true and isRelaxationReached is true
 
  
    tIndex &iStep=getStepIndex();
    iStep=0;
    //std::cout<<" step="<<iStep<<" steppers number :"<<steppersNumber<<" mIsRelaxed="<<mIsRelaxed<<" isRelaxationReached:"<<isRelaxationReached<<"\n";
    while ( (iStep<steppersNumber) && ( (!mIsRelaxed)  || (!isRelaxationReached)) )  {//loop on time
 
        //progress bar
        //std::cout<<iStep<<"/"<<steppersNumber<<"  mIsRelaxed:"<<mIsRelaxed<<" isRelaxationReached:"<<isRelaxationReached<<" relaxation:"<<relaxationValue<<"\n";
        
        //step to save the stochastic output > 0
        iDrawnStep++;
        
 
        
        //update state of operators
        //std::cout<<"update operator for step "<<iStep<<"\n";
        updateOperatorsState(timeIndex,network,material,St);
        
        
        //compute H
        //std::cout<<" compute Ht for step "<<iStep<<"\n";
        computeMagneticField(timeIndex,network,material,St,Ht);
 
        //is relaxed
        //std::cout<<"compute Net Torque for step "<<iStep<<"\n";
        relaxationValue=computeNetTorque();
        isRelaxationReached=(fabs(relaxationValue)<mRelaxationTolerance);
        //std::cout<<iStep<<":\t"<<relaxationValue<<"\t"<<isRelaxationReached<<"\n";
 
        //store stochastic output each drawnStep
        if (iDrawnStep==nDrawnSteps) {
            //std::cout<<"SO.store() for step "<<iStep<<"\n";
            stochasticOutput.store(*this);
            iDrawnStep=0;
        }
        
      
        //H:=dt.H
        //std::cout<<" compute dHt for step "<<iStep<<"\n";
        computeVariationMagneticField(dt,Ht);
        
 
                                    
        //compute the landau lifchitz function Delta S_t=LL(St,dHt)
        //std::cout<<" compute LL(St,Ht) for step "<<iStep<<"\n";
        llFunction.computeFunction(nParticles,St,Ht,DeltaSt);
 
        //compute S at next time step
        //std::cout<<"begin "<<getIdentityString()<<"::computeNextS for step "<<iStep<<"\n";
        if (!computeMagneticMomentDirectionsAtNextTimeStep(dt,0,DeltaSt,St)) {
            //the algorithm diverges
            //break the loop
            succeeds=false;
            break;
        }
        //std::cout<<"end "<<getIdentityString()<<"::computeNextS for step "<<iStep<<"\n";
        
       
        
        //next time step
        time+=dt;//time at next time step
        timeIndex++;
        iStep++;
        
    }
    
    //store the stochastix stochasticOutput at last time
    
    //compute h
    //computeMagneticField(timeIndex,network,material,St,Ht);
 
    CORE_Profiler::EndCallRoutine(routineName);
    
    return succeeds;
}
 
 
//stochastic case
//================
  
template<class StochOutputImplement>
tBoolean SM_LandauLifschitzSystem::stochasticRun(const tIndex& steppersNumber,
                                                 SM_MultiStochasticFunctionsInterface& multiStochasticFunctions,
                                                 SM_StochasticOutput<StochOutputImplement>& stochasticOutput) {
    tString routineName="SM_LandauLifschitzSystem::stochasticRun<StochasticOutput>(const tIndex&, SM_StochasticFunctions&,StochasticOutput&)";
    CORE_Profiler::StartCallRoutine(routineName);
    
    //number of drawn for stochastic output 
    tInteger nDrawnSteps=stochasticOutput.getDrawnStepsNumber();
    if (nDrawnSteps==0) nDrawnSteps=steppersNumber+1;
    
    //return value
    tBoolean succeeds=true;
    
    //network of the system
    const SM_Network& network=this->getNetwork();
 
    //material of the system
    const SM_Material& material=this->getMaterial();
 
    //number of particles
    const tIndex& nParticles=network.getParticlesNumber();
 
 
    //get direction of magnetic moments
    SM_RealField& St=this->getMagneticMomentDirections();
   
    //get the variation of the dierction of the magnetic moment
    SM_RealField& DeltaSt=this->getMagneticMomentDirectionsVariation();
    
    //magnetic field 
    SM_RealField &Ht=this->getMagneticField();
 
   
    //time stepper
    const SM_TimeStepper& timeStepper=this->getTimeStepper();
 
    //time step
    const tReal& dt=timeStepper.getTimeStep();
 
    //square root of time step for Brownian perturbation
    tReal Wdt=sqrt(dt);
 
  
   
    //index of time
    tIndex& timeIndex=this->getTimeIndex();  
 
    //current time
    tReal &time=this->getTime();
    time=dt;
    time*=timeIndex;
    
    //LL Function
    const SM_LandauLifschitzFunction& llFunction=this->getLandauLifschitzFunction();
    
 
    //get the noise rate function
    SM_NoiseRateFunctionInterface& noiseRateFunction=getNoiseRateFunction();
    
    //epsilon depending on time
    tReal& epsilon_t=this->getNoiseRate();
 
 
    //drawn Step
    tInteger iDrawnStep=0;
 
 
    //brownian perturbation variable or field
    tReal dWt=0;
    tBoolean incDWt=(!mIsRealBrownianVariable);
    tReal *iDWt=&dWt;
    
    //iterator on brownian field
    if (incDWt && (mDeltaWt.getSize()>0)) iDWt=&mDeltaWt[0];
    
    tIndex& iStep=getStepIndex();
    iStep=0;
    while (iStep<steppersNumber) {//loop on time
 
        //progress bar
        //std::cout<<"SM_LLSystem::stochasticRun(..) : "<<iStep<<"/"<<steppersNumber<<"                      \n";
        
        //step to save the stochastic output
        iDrawnStep++;
 
        
        //compute epsilon_t by casting of computeFunction method
        epsilon_t=noiseRateFunction.computeFunction(time);
 
        //update state of operators
        updateOperatorsState(timeIndex,network,material,St);
        
        //compute H
        computeMagneticField(timeIndex,network,material,St,Ht);
 
        //store stochastic output each drawnStep
        if (iDrawnStep==nDrawnSteps) {
            //std::cout<<"begin storing Stoch Outputs "<<stochasticOutput.getIdentityString()<<"\n";
            stochasticOutput.store(*this);
            //std::cout<<"end storing Stoch Outputs\n";
            iDrawnStep=0;
        }
        
        //H:=dt.H+epsilon_t . w(dt). N(0,1)
        //std::cout<<"compute dHt\n";
        if (epsilon_t!=0) {
            //H:=dt.H+epsilon_t . w(dt). N(0,1)
            computeBrownianVariationMagneticField(multiStochasticFunctions,dt,Wdt,epsilon_t,
                                                  incDWt,iDWt,Ht);
        } else {
            //H:=dt.H
            computeVariationMagneticField(dt,Ht);
        }
       
        //std::cout<<"compute DSt\n";
        //compute the landau lifchitz function Delta S_t=LL(St,dHt)
        llFunction.computeFunction(nParticles,St,Ht,DeltaSt);
 
        
        //compute S at next time step
        //std::cout<<"compute St+dt\n";
        if (!computeMagneticMomentDirectionsAtNextTimeStep(dt,epsilon_t,DeltaSt,St)) {
            //the algorithm diverges
            //break the loop
            succeeds=false;
            break;
        }
        
        //next time step
        time+=dt;//time at next time step
        timeIndex++;//next time index
        iStep++;
    }
    //progress bar
    //std::cout<<"end SM_LLSystem::stochasticRun(..)";
    CORE_Profiler::EndCallRoutine(routineName);
    return succeeds;
}
 
 
 
//Random J connection
 
//stochastic case
//================
 
template<class StochOutputImpl>
tBoolean SM_LandauLifschitzSystem::stochasticJRun(const tIndex& steppersNumber,
                                                  SM_StochasticFunctionsInterface& stochasticFunctions,
                                                  SM_StochasticOutput<StochOutputImpl>& stochasticOutput,
                                                  const std::function<void(const tReal&,const tReal& ,const tReal&,tReal& )>& F) {
    tString routineName="SM_LandauLifschitzSystem::stochasticJRun<StochasticOutput>(const tIndex&, SM_StochasticFunctions&,StochasticOutput&)";
    CORE_Profiler::StartCallRoutine(routineName);
    
    //number of drawn for stochastic output 
    tInteger nDrawnSteps=stochasticOutput.getDrawnStepsNumber();
    if (nDrawnSteps==0) nDrawnSteps=steppersNumber+1;
    
    //return value
    tBoolean succeeds=true;
    
    //network of the system
    SM_Network& network=this->getNetwork();
 
    //material of the system
    const SM_Material& material=this->getMaterial();
    
    //adimensionized exhange factor
    const tReal& J=material.getAdimensionizedExchangeEnergyFactor();
    
    //number of particles
    const tIndex& nParticles=network.getParticlesNumber();
    
    //get direction of magnetic moments
    SM_RealField& St=this->getMagneticMomentDirections();
   
    //get the variation of the dierction of the magnetic moment
    SM_RealField& DeltaSt=this->getMagneticMomentDirectionsVariation();
    
    //magnetic field 
    SM_RealField &Ht=this->getMagneticField();
 
    //time stepper
    const SM_TimeStepper& timeStepper=this->getTimeStepper();
 
    //time step
    const tReal& dt=timeStepper.getTimeStep();
 
   
    //index of time
    tIndex& timeIndex=this->getTimeIndex();  
 
    //current time
    tReal &time=this->getTime();
    time=dt;
    time*=timeIndex;
    
    //LL Function
    const SM_LandauLifschitzFunction& llFunction=this->getLandauLifschitzFunction();
   
    //stochastic noise
    const tReal& epsilon=this->getStochasticNoise();
 
 
    //drawn Step
    tInteger iDrawnStep=0;
    
    tIndex& iStep=getStepIndex();
    iStep=0;
    while (iStep<steppersNumber) {//loop on time
 
        //step to save the stochastic output
        iDrawnStep++;
 
 
        //compute random J
        network.updateConnectionValues(epsilon,stochasticFunctions,J,F);
 
        //update state of operators
        updateOperatorsState(timeIndex,network,material,St);
        
        //compute H
        computeMagneticField(timeIndex,network,material,St,Ht);
 
        //store stochastic output each drawnStep
        if (iDrawnStep==nDrawnSteps) {
            stochasticOutput.store(*this);
            iDrawnStep=0;
        }
      
        //H:=dt.H
        computeVariationMagneticField(dt,Ht);
        
       
       
        //compute the landau lifchitz function Delta S_t=LL(St,dHt)
        llFunction.computeFunction(nParticles,St,Ht,DeltaSt);
 
        
        //compute S at next time step
        if (!computeMagneticMomentDirectionsAtNextTimeStep(dt,epsilon,DeltaSt,St)) {
            //the algorithm diverges
            //break the loop
            succeeds=false;
            break;
        }
        
        //next time step
        time+=dt;//time at next time step
        timeIndex++;//next time index
        iStep++;
    }
    
    //store the stochastix output at time
    
    CORE_Profiler::EndCallRoutine(routineName);
    return succeeds;
}