SM_LandauLifschitzOptions.h

#ifndef SM_LandauLifschitzOptions_H
#define SM_LandauLifschitzOptions_H
 
//supez class header
#include "SM_Options.h"
 
class SM_LandauLifschitzOptions : public virtual  SM_Options {
    
    //attributes
private :
    
    
    
protected:
    // CONSTRUCTORS 
    SM_LandauLifschitzOptions(void) {
    }//end constructor method
  
    // DESTRUCTORS 
    virtual ~SM_LandauLifschitzOptions(void) {
    }//end destructor method
    
 
 
public : 
    //MEMORY
    
    virtual tMemSize getMemorySize() const override{
        return sizeof(*this)+getContentsMemorySize();
    }//end getMemorySize Method
    
 
    //shared pointer methods
    //======================
     
    static inline CORE_UniquePointer<SM_LandauLifschitzOptions> New() {
        return CORE_UniquePointer<SM_LandauLifschitzOptions>(new SM_LandauLifschitzOptions(),
                                                             SM_LandauLifschitzOptions::Delete());
    }//end New method
 
    
    // MAIN Method
 
public:
  
public:
    virtual void initManOptions(CORE_OptionsList& options) const override {
        
        SM_Options::initManOptions(options);
        tString tab="\n\t\t\t";
 
        
    
        
        //L
        options.setManOption("LL","LL-system","stochastic model in {ito,stratonovich,stratonovich-n,heun}");
        options.setManOption("LL","LL-lambda","microscopic damping parameter");
        options.setManOption("LL","LL-type","Landau Lischitz type in ('LL','NLL'} NLL: the first argument is supposed to be normalized ");
        options.setManOption("LL","noise","stochastic noise type in {'',constant,inverse}");
        options.setManOption("LL","time-step","initial time step in s ");
        options.setManOption("LL","time-stepper","kind of the stepper in {constant}");
        
        options.setManOption("LL","use-relaxation","true to use relaxation for deterministic system");
        options.setManOption("LL","relaxation-tolerance","relaxation tolerance when relaxation is used");
        
        
    }//end initManOptions method
    
    virtual void initOptions(CORE_OptionsList& options) const override {
        SM_Options::initOptions(options);
 
      
 
       
        //Landau lisfchitz system default options
        options.setOptionValue("LL-system","stratonovich-n");
        options.setOptionValue("LL-lambda",0.5);
        options.setOptionValue("LL-type","ll");
        options.setOptionValue("noise","constant");
        options.setOptionValue("time-step",1.e-15);
        options.setOptionValue("time-stepper","constant");
        options.setOptionValue("use-relaxation","false");
        options.setOptionValue("relaxation-tolerance",1.e-8);
     
      
    }//end initOptions method
    
    
    
};//end class method
 
 
#endif