SM_StratonovichNormalizedSystem.h

Go to the documentation of this file.

#ifndef SM_StratonovichNormalizedSystem_H
#define SM_StratonovichNormalizedSystem_H
 
#include "SM_TemplatedSystem.h"
 
class SM_StratonovichNormalizedSystem : public SM_TemplatedSystem<SM_StratonovichNormalizedSystem> {
   
    //attributes
private :
 
    
  
    tReal mK;//the stratonovich constant for LL function
    
public:
    // CONSTRUCTORS 
    SM_StratonovichNormalizedSystem(void) {
        
    }
    
    // DESTRUCTORS 
    virtual ~SM_StratonovichNormalizedSystem(void) {
    }
 
 
public : 
   
    inline static CORE_UniquePointer<SM_StratonovichNormalizedSystem> New() {
        return CORE_UniquePointer<SM_StratonovichNormalizedSystem>(new SM_StratonovichNormalizedSystem(),
                                                                   SM_StratonovichNormalizedSystem::Delete());
    }
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
 
public:
  
    inline const tReal& getK() const {
        return mK;
    }
    
public:
    virtual void discretize() override {
        SM_TemplatedSystem<SM_StratonovichNormalizedSystem>::discretize();
        const SM_LandauLifschitzFunction &ll=this->getLandauLifschitzFunction();
        const tReal& alpha=ll.getAlpha();
        const tReal& beta=ll.getBeta();
        mK=alpha*alpha*(1+beta*beta);
        
    }
    
 
 
public:
   
    inline tBoolean  computeTemplatedMuAtNextTimeStep(const tReal& dt,const tReal& epsilon_t,
                                                      const tIndex& nParticles,const tDimension& dim,
                                                      const tReal* mu_t,
                                                      tReal *mu_tpdt)  const {
        
        const tReal &K=this->getK();
        
        //inverse of norm of Mu
        tReal invNormMu=0;
 
        //iterator on point
        tIndex p;
        
        //iterator on dimension
        tDimension k;
        
        //iterator on mu(t+dt)
        tReal *mu_tpdt_p,*mu_tpdt_i=mu_tpdt;
        
        //iterator on mu(t)
        const tReal *mu_t_i=mu_t;
 
     
        for (p=0;p<nParticles;p++) {
            //mu(t+dt) at particule p
            mu_tpdt_p=mu_tpdt_i;
            //inverse of norm of mu
            invNormMu=0;
            
            for (k=0;k<dim;k++) {
                //mu(t+dt) at element i=(p,k)
                (*mu_tpdt_i)+=(1-K*epsilon_t*epsilon_t*dt)*(*mu_t_i);
                //norm of mu(t+dt) at p
                invNormMu+=(*mu_tpdt_i)*(*mu_tpdt_i);
                
                //next element
                mu_tpdt_i++;
                mu_t_i++;
                    
            }
            if (invNormMu>EPSILON<tReal>) {
                //normlize mu(t+dt) at p
                invNormMu=1./sqrt(invNormMu);
                mu_tpdt_i=mu_tpdt_p;
                for (k=0;k<3;k++) {
                    (*mu_tpdt_i)*=invNormMu;
                    mu_tpdt_i++;
                }
            }
                
        }
      
        
        
        //because of nomalization the norm of mu is never greater than 1
        return true;
    }
    
};
 
 
#endif