SM_Options.h

#ifndef SM_Options_H
#define SM_Options_H
 
//inherits header
#include "CORE_Options.h"
 
class SM_Options : public virtual CORE_Options {
    
    //attributes
private :
    
    
    
protected:
    // CONSTRUCTORS 
    SM_Options(void) {
    }//end constructor method
  
    // DESTRUCTORS 
    virtual ~SM_Options(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_Options> New() {
        return CORE_UniquePointer<SM_Options>(new SM_Options(),
                                              SM_Options::Delete());
    }
    
    
 
    
    // MAIN Method
 
public:
  
public:
    virtual void initManOptions(CORE_OptionsList& options) const override {
        
        CORE_Options::initManOptions(options);
        
        tString tab="\n\t\t\t";
        
        //beam
        options.setManOption("beam","simulations-number","number of simulations");
        options.setManOption("beam","beam"," beam in {'laudau-lifschitz', 'monte-carlo'}");
        
       
        
        //stochastic function
        options.setManOption("stochastic","seed","seed of the random number generator at the begining of the beam simulations running. If negative seed is set to times(null)");
        options.setManOption("stochastic","random-distribution","random distribution function in {'','boost','std','trng','mt'}");
        options.setManOption("stochastic","random-generator","random number generator in  {'','mt19937','lcg64','yarn2','mrg2','mrg3','mrg4','mrg5','mrg3s','mrg5s'}");
        
        //materials
        options.setManOption("material","material-name","name of the material");
        options.setManOption("material","mu_s","Atomic magnetic moment (x Mu_B ) Mu_B=9.2740e−24");
        options.setManOption("material","J","exhange energy factor J/link)");
        options.setManOption("material","D","DMI energy factor in RxRxR in J/link)");
        options.setManOption("material","MF-correction","spin wave MF correction)");
        options.setManOption("material","Ku","anisotropy energy factor (J/atom)");
        options.setManOption("material","U","anisotropy directions ");
        options.setManOption("material","crystal-type","anisotropy type in {uniaxial,planar,cubic} ");
        options.setManOption("material","adimensionize","true to adimensionize");
 
 
        //crystal-structure
        options.setManOption("crystal structure","crystal-structure","bame of the structure in {bcc,fcc,line,grid2d,cgrid2d,grid3d,cgrid3d}");
        options.setManOption("crystal structure","crystal-cell-size","[Hx,Hy,Hz] cell size in unit Angstroms of the structure");
        //options.setManOption("material","crystal-is-atoms-number-uniform","atoms number per unit cell is uniform or not");
        
 
        //network
        options.setManOption("network","network-file","absolute/data path relative name of the network file ");
        options.setManOption("network","network-size","[Nx,Ny,Nz] size of the network");
        options.setManOption("network","network-periodicity","[Tx,Ty,Tz] periodicity on periodic cells");
        options.setManOption("network","network-domain","domain definition of the network file");;
        
        //system
        options.setManOption("system","S0","initial direction of magnetic moment in file or vector [S0.x,S0.y,S0.z]");
        options.setManOption("system","is-S-saved","true to save the S at end of simulations");
        options.setManOption("system","preconditioning-steps-number","number of  steps for the system to reach the equilibrium");
        options.setManOption("system","steps-number","number of  steps for the system after the equilibrium is reached");
      
        
        //zeeman operator
        options.setManOption("operator","use-zeeman","true to use zeeman operator");
        //heisenberg operator:
        options.setManOption("operator","use-exchange","true to use exchange operator");
        //DMI operator:
        options.setManOption("operator","use-dmi","true to use DMI operator");
        
        //dipolar operator
        options.setManOption("operator","use-dipolar","true to use dipolar operator");
        options.setManOption("operator","use-macro-cell-dipolar","true to use macro cell dipolar operator instead of dipolar operator");
        
        //anisotropy operator
        options.setManOption("operator","use-anisotropy","true to use anisotropy operator");
        
        //zeeman data 
        options.setManOption("operator/zeeman","Hext","external field in Tesla (T)");
        
        //macro cell dipolar data
        options.setManOption("operator/macroCellDipolar","macro-cell-demagnetized-type","in {'as-external','continuous'}");
        options.setManOption("operator/macroCellDipolar","macro-cell-demagnetized-updating-steps-number","steps number for updating demagnetized field");
        options.setManOption("operator/macroCellDipolar","macro-cell-size","size of the macro cell in Angstrom ");
        options.setManOption("operator/macroCellDipolar","macro-cell-margin","margin to build the macro cells in Angstrom");
        options.setManOption("operator/macroCellDipolar","macro-cell-matrix","type of storage of the matrix={'packed-storage','','no-storage'}");
        options.setManOption("operator/macroCellDipolar","macro-cell-core-type","type of core for macro cell computing in {'','master-<id>','all-master','no-master'}");
        
        //noise Temperature
        options.setManOption("noise","temperature","temperature in Kelvin");
        
        //stochastic noise
        options.setManOption("noise","stochastic-noise","the stochastic noise");
        
        
        //output
        std::stringstream drawnsMan;
        drawnsMan<<"number of steps to make a drawn for computing stochastic data"<<"\n";
        drawnsMan<<"\t\t\t 0: stochastic output is not called for each loop's stepper \n";
        drawnsMan<<"\t\t\t s: stochastic output is called each s loop's steppers \n";
        drawnsMan<<"\t\t\t the stochastic output is called at";
        drawnsMan<<"\t\t\t\t - begining & ending of the beam simulations running \n";
        drawnsMan<<"\t\t\t\t - begining & ending of one simulation of the beam \n";
        options.setManOption("stochastic-output","stochastic-drawn-steps-number",drawnsMan.str());
        options.setManOption("stochastic-output","stochastic-outputs","stochastic outputs list in {'trajectory','xdmf'}");
 
 
          
        //runner
        options.setManOption("runner","is-templated-run","true to run the templated run method for beam");
        
        //cyclle
        options.setManOption("cycle","is-step-cycle-seed-updated","true|false to update seed at each step of cycle");
        options.setManOption("cycle","is-cycle-restoring","true to restore the cycle");
        options.setManOption("cycle","is-stochastic-output-saved-at-each-cycle-step","true to save stochastic output at each cyle step");
        
        options.setManOption("cycle","hysteresis-Hext-range","hext ranges [Hext_0,Hext_1,nHexts] Hext_i a 3D vector in Tesla");
        options.setManOption("cycle","hysteresis-backups-number","number of backups");
        options.setManOption("cycle","hysteresis-backup-steps-number","number of cycle steps between 2 backups");
        options.setManOption("cycle","hysteresis-are-critical-points-saved","true to save spin directions at critical points");
        options.setManOption("cycle","temperature-range","temperature ranges [T_0,T_1,DT] in Kelvin");
        options.setManOption("cycle","stochastic-range","stochastic range for J");
        options.setManOption("cycle","time-step-range","log of time step in ps ranges [dt_0,dt_1,ddt]");
 
 
        //stochastic output
        std::stringstream v;
        v<<"[\"xdmf\",\"trajectory\"] \n";
        v<<"\t xdmf: save in an xdmf file at any time the direction of magnetic moments for epsilon=stochastic-noise-rate and simulation=stochastic-simulations \n";
        v<<"\t trajectory: save in a text fiml at any time the direction of magnetic moments at stochastic-particles for epsilon=stochastic-noise-rate and simulation=stochastic-simulations \n";
        
        options.setManOption("stochastic-output","stochastic-outputs",v.str());
        options.setManOption("stochastic-output","stochastic-simulations","simulation array indices to save trajectories in txt/xdmf files ");
        options.setManOption("stochastic-output","stochastic-particles","particles array indices to save trajectories in txt files");
        options.setManOption("stochastic-output","stochastic-JFunction","JFunctionName in {increase,decrease,cubic-decrease}");
        
    }//end initManOptions method
    
    virtual void initOptions(CORE_OptionsList& options) const override {
        CORE_Options::initOptions(options);
 
        //options 
        options.setOptionValue("is-options-name-case-sensitive",false);
 
        //OpenMP options
        options.setOptionValue("threads-number",0);
        
        //beam default options
        options.setOptionValue("beam","landau-lifschitz");
        //number of simulations
        options.setOptionValue("simulations-number",1);
        //stepper default options
        options.setOptionValue("preconditioning-steps-number",0);
        options.setOptionValue("steps-number",1000);
        
        //stochastic defualt options
        options.setOptionValue("seed",0);
        options.setOptionValue("random-distribution","trng");
        options.setOptionValue("random-generator","mt19937");
          
        //materials default options
        
        options.setOptionValue("material-name","Fer");
        options.setOptionValue("MF-correction",0.766);
        options.setOptionValue("mu_s",2.22);
        options.setOptionValue("J",7051e-24);
        options.setOptionValue("Ku",0.565e-24);
        options.setOptionValue("U",{1,0,0});
        options.setOptionValue("crystal-type","uniaxial");
        //options.setOptionValue("crystal-is-atoms-number-uniform","false");
       
 
        //crsyatl structure
        options.setOptionValue("crystal-structure","bcc");
        options.setOptionValue("crystal-cell-size",{2.8661});
        
        //network default option
        options.setOptionValue("network-size",{10,10,100});
        options.setOptionValue("network-periodicity",{false});
        
        //system default options
        options.setOptionValue("S0","[0,1,0]");
        options.setOptionValue("is-S-saved","true");
        
       
 
        //operators defult options
        options.setOptionValue("use-exchange",false);
        options.setOptionValue("use-anisotropy",false);
        options.setOptionValue("use-zeeman",false);
        options.setOptionValue("use-dipolar",false);
        options.setOptionValue("use-macro-cell-dipolar",false);
    
 
        
        options.setOptionValue("Hext",{0,0,0});
 
        options.setOptionValue("macro-cell-demagnetized-type","external");
        options.setOptionValue("macro-cell-demagnetized-updating-steps-number",10);
        options.setOptionValue("macro-cell-size",{2,2,2});
        options.setOptionValue("macro-cell-margin",1.e-4);
        options.setOptionValue("macro-cell-core-type","no-master");
        
        //mc options by default
        options.setOptionValue("temperature",0);
        options.setOptionValue("stochastic-noise",0);
          
        options.setOptionValue("is-templated-run",false);
        
        //output stochastic data
        options.setOptionValue("stochastic-drawn-steps-number",1);
           
        options.setOptionValue("stochastic-simulations",{0});
        options.setOptionValue("stochastic-particles",{0});
        options.setOptionValue("is-stochastic-output-saved-at-each-cycle-step",true);
        
        options.setOptionValue("stochastic-JFunction","increase");
      
      
    }//end initOptions method
    
    
    
};//end class method
 
 
#endif