SMOMPI_LandauLifschitzSystem.hpp

#ifndef SMOMPI_LandauLifschitzSystem_HPP
#define SMOMPI_LandauLifschitzSystem_HPP
 
//MPI header
#include "MPI_Run.h"
 
template<class StochFImpl>
void SMOMPI_LandauLifschitzSystem::computeBrownianVariationMagneticFieldWithSCStochasticFunctions(SM_MultiStochasticFunctions<StochFImpl>& stochFs,
                                                                                                  const tReal& dt,const tReal& bdt,const tReal& epsilon,
                                                                                                  const tBoolean& incdWt,tReal* dWt,SM_RealField& H) {
 
    
    //number of elements of H
    tIndex nH=H.getElementsNumber();
    if (nH==0) return;
    
    //MPI environment
    //const MPI_Environment& mpiEnv=MPI_Run::GetEnvironment();
    
    //current id of the MPI core
    //const tMPICoreId& coreId=mpiEnv.getCoreId();
    
    //number of MPI cores
    //const tMPICoreId& coresNumber=mpiEnv.getCoresNumber();
 
    //number of particles of the network
    tInteger nParticles=getNetwork().getParticlesNumber();
    
  
 
    
    computeBrownianVariationMagneticFieldSliceWithSCStochasticFunctions(stochFs[0],0,nParticles,
                                                                        dt,bdt,epsilon,
                                                                        incdWt,dWt,&H[0]);
    
} 
 
//templated stochastic case without statistics computing
//=======================================================
template<class StochFImpl, class NoiseFImpl>
tBoolean SMOMPI_LandauLifschitzSystem::stochasticRunWithSCStochasticFunctions(const tIndex& steppersNumber,
                                                                              SM_MultiStochasticFunctions<StochFImpl>& stochasticFunctions,
                                                                              const SM_NoiseRateFunction<NoiseFImpl>& noiseRateFunction) {
    tString routineName="SM_LandauLifschitzSystem::stochasticRunWithSCStochasticFunctions<StochFI,NoiseI>(const tIndex&,StochFI&,const NoiseI&)";
    CORE_Profiler::StartCallRoutine(routineName);
    //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 tInteger& nParticles=getNetwork().getParticlesNumber();
 
    //number of halo particles
    const tInteger& nHaloParticles=getNetwork().getHaloParticlesNumber();
    
    //field array size & iterator on it
    tIndex s=(nParticles+nHaloParticles)*SM_Constants::DIM;
 
    //get direction of magnetic moments
    SM_RealField& St=this->getMagneticMomentDirections();
    if (St.getSize()!=s) {
        throw CORE_Exception("stochmagnet/landauLifschitz",
                             "SMOMPI_LandauLifschitzSystem::templatedStochasticRun()",
                             "atomic spin directions has bad size : "+std::to_string(St.getSize())+" ("+std::to_string(s)+")" );
    }
    //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();
    
    
    //epsilon depending on time
    tReal& epsilon_t=this->getNoiseRate();
 
 
 
 
    //brownian perturbation variable or field
    tReal dWt=0;
    tBoolean incDWt=(!isRealBrownianVariable());
    tReal *iDWt=&dWt;
    if (incDWt && (getBrownianField().getElementsNumber()>0)  ) {
        iDWt=&getBrownianField()[0];
    }
 
    tIndex &iStep=getStepIndex();
    iStep=0;
    while (iStep<steppersNumber) {//loop on time
 
        //std::cout<<"preconditioning step: "<< iStep<<"/"<<steppersNumber<<"                              \r";
        
        //compute epsilon_t by casting of computeFunction method
        epsilon_t=noiseRateFunction.computeFunction(time);
        
        //compute H
        computeMagneticField(timeIndex,network,material,St,Ht);
        
        //H:=dt.H+epsilon_t . w(dt). N(0,1)
        if (epsilon_t!=0) {
            //H:=dt.H+epsilon_t . w(dt). N(0,1)
            computeBrownianVariationMagneticFieldWithSCStochasticFunctions(stochasticFunctions,dt,Wdt,epsilon_t,
                                                                           incDWt,iDWt,Ht);
        } else {
            //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_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++;
    }
    
    //store the stochastix output at time
    
 
        
    CORE_Profiler::EndCallRoutine(routineName);
    return succeeds;
}
    
 
//templated stochastic case with     statistics computing
//=======================================================
template<class StochFImpl, class NoiseImpl,class StochOutputImpl>
tBoolean SMOMPI_LandauLifschitzSystem::stochasticRunWithSCStochasticFunctions(const tIndex& steppersNumber,
                                                                              SM_MultiStochasticFunctions<StochFImpl>& stochasticFunctions,
                                                                              const SM_NoiseRateFunction<NoiseImpl>& noiseRateFunction,
                                                                              SM_StochasticOutput<StochOutputImpl>& stochasticOutput) {
    tString routineName="SM_LandauLifschitzSystem::stochasticRunWithSCStochasticFunctions<StochFI,NoiseI,StochoOutputI>(const tIndex&,StochI&,const NoiseI&,StochOutputI&)";
    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();
    
    //number of halo particles
    const tIndex& nHaloParticles=network.getHaloParticlesNumber();
    
    //field array size & iterator on it
    tIndex s=(nParticles+nHaloParticles)*SM_Constants::DIM;
 
    //get direction of magnetic moments
    SM_RealField& St=this->getMagneticMomentDirections();
    if (St.getSize()!=s) {
        throw CORE_Exception("stochmagnet/landauLifschitz",
                             "SM_LandauLifschitzSystem::templatedStochasticRun()",
                             "atomic spin directions has bad size : "+std::to_string(St.getSize())+" ("+std::to_string(s)+")");
    }
    //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();
    
  
    //epsilon depending on time
    tReal& epsilon_t=this->getNoiseRate();
 
 
    //drawn Step
    tInteger iDrawnStep=0;
 
 
    //brownian perturbation variable or field
    tReal dWt=0;
    tBoolean incDWt=(!isRealBrownianVariable());
    tReal *iDWt=&dWt;
    if (incDWt && (getBrownianField().getElementsNumber()>0)) iDWt=&getBrownianField()[0];
    
    
    tIndex& iStep=getStepIndex();
    iStep=0;
    while (iStep<steppersNumber) {//loop on time
 
        //std::cout<<"statistic step: "<< iStep<<"/"<<steppersNumber<<"                                                     \r";
        //step to save the stochastic output
        iDrawnStep++;
 
        
        //compute epsilon_t by casting of computeFunction method
        epsilon_t=noiseRateFunction.computeSCFunction(time);
        
        //compute H
        computeMagneticField(timeIndex,network,material,St,Ht);
        
        //store stochastic output each drawnStep
        if (iDrawnStep==nDrawnSteps) {
            stochasticOutput.store(*this);
            iDrawnStep=0;
        }
        
        //H:=dt.H+epsilon_t . w(dt). N(0,1)
        if (epsilon_t!=0) {
            //H:=dt.H+epsilon_t . w(dt). N(0,1)
            computeBrownianVariationMagneticFieldWithSCStochasticFunctions(stochasticFunctions,dt,Wdt,epsilon_t,
                                                                           incDWt,iDWt,Ht);
        } else {
            //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_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++;
    }
    
    //store the stochastix output at time
 
 
    //built-in profiler
    CORE_Profiler::EndCallRoutine(routineName);
    
    return succeeds;
}
    
#endif