SMOMPI_LandauLifschitzSystem.h

#ifndef SMOMPI_LandauLifschitzSystem_H
#define SMOMPI_LandauLifschitzSystem_H
 
//base class
#include "SM_LandauLifschitzSystem.h"
 
 
#include "SMOMPI_LandauLifschitzFunction.h"
 
#include "MPI_Run.h"
 
class SMOMPI_LandauLifschitzSystem : public SM_LandauLifschitzSystem  {
   
    //attributes
private :
 
    
    typedef SMOMPI_LandauLifschitzSystem Self;
    typedef SM_LandauLifschitzSystem SuperClass;
 
   
    
protected:
    // CONSTRUCTORS 
    SMOMPI_LandauLifschitzSystem(void) {
        
        setLandauLifschitzFunction(SMOMPI_LandauLifschitzFunction::New());
    }
    
    
    // DESTRUCTORS 
    virtual ~SMOMPI_LandauLifschitzSystem(void) {
    }
 
 
public : 
 
     
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        return mem;
    }
    
    //SET & GET methods
 
 
    //Esparance methods
    //====================
    virtual void sumOverNetworks(const int& rootNetwork,tIndex& n,const tIndex& nValues,tReal* values) const final;
  
    //runner methods
    //================
 
    void discretize()  override ;
       
    virtual tBoolean updateInitialMagneticMomentDirections(const SM_RealField& S0) final;
    
    virtual tBoolean  initializeMagneticMomentDirections() final;
 
   
 
   
    template<class StochFImplement, class NoiseFImplement>
    tBoolean stochasticRunWithSCStochasticFunctions(const tIndex& steppersNumber,
                                                    SM_MultiStochasticFunctions<StochFImplement>& stochasticFunctions,
                                                    const SM_NoiseRateFunction<NoiseFImplement>& noiseRateFunction);
    
    template<class StochFImplement, class NoiseImplement,class StochOutputImplement>
    tBoolean stochasticRunWithSCStochasticFunctions(const tIndex& steppersNumber,
                                                    SM_MultiStochasticFunctions<StochFImplement>& stochasticFunctions,
                                                    const SM_NoiseRateFunction<NoiseImplement>& noiseRateFunction,
                                                    SM_StochasticOutput<StochOutputImplement>& stochasticOutput);
    
    
    //relaxation methods
    //=================
  
    virtual tReal computeNetTorque(const tIndex& nSParticles,const tReal* S,
                                   const tIndex& nHParticles,const tReal* H) const final;
 
 
    // DH methods
    //===========
 
     
    virtual void computeVariationMagneticField(const tReal& dt,SM_RealField& H) const final;
 
    
    virtual void computeBrownianVariationMagneticField(SM_MultiStochasticFunctionsInterface& stochFs,
                                                       const tReal& dt,const tReal& bdt,const tReal& epsilon,
                                                       const tBoolean& incdWt,tReal* dWt,SM_RealField& H) final;
    
    
    template<class StochFImpl>
    void computeBrownianVariationMagneticFieldWithSCStochasticFunctions(SM_MultiStochasticFunctions<StochFImpl>& stochFs,
                                                                        const tReal& dt,const tReal& bdt,const tReal& epsilon,
                                                                        const tBoolean& incdWt,tReal* dWt,SM_RealField& H);
    
 
 
    //next direction of magnetic moments method
    //========================================
    
    
         
    static  void  ComputeMagneticMomentDirectionsAtNextTimeStep(const tIndex& nParticles,
                                                                const SM_RealField& deltaS,
                                                                const SM_RealField& S,
                                                                SM_RealField& nextS);
    
    static void  ComputeMagneticMomentDirectionsAtNextTimeStep(const tIndex& nParticles,
                                                               const SM_RealField& deltaSt,
                                                               const tReal& alpha,
                                                               const SM_RealField& S,
                                                               SM_RealField& nextS);
 
 
                                                               
};
 
#include "SMOMPI_LandauLifschitzSystem.hpp"
#endif