settings.h

Go to the documentation of this file.

#ifndef settings_h
#define settings_h
 
#include <cmath>
#include <string>
#include <vector>
 
#include <yaml-cpp/yaml.h>
 
#include "expression_parser.h"
#include "triangle.h"
#include "tetra.h"
 
enum mag_exprType
    {
    POSITION_ONLY,        
    POSITION_AND_REGIONS  
    };
 
enum field_exprType
    {
    UNDEF = -1,  
    RtoR3 = 1,   
    R4toR3 = 2   
    };
 
class Settings
    {
public:
    Settings();
 
    static void dumpDefaults();
 
    static void dumpTemplate();
 
    void toYaml(void);
 
    std::string evolMetadata() const;
 
    std::string solMetadata(const double t) const;
 
    void read(YAML::Node);
 
    bool read(const std::string& filename);
 
    inline int getPrecision(void) const { return precision; }
 
    inline std::string getFileDisplayName(void) const { return fileDisplayName; }
 
    inline void setFileDisplayName(const std::string &_s) { fileDisplayName = _s; }
 
    inline void setPbName(const std::string &str) { pbName = str; }
 
    inline std::string getPbName(void) const { return pbName; }
 
    inline void setSimName(const std::string &str) { simName = str; }
 
    inline std::string getSimName(void) const { return simName; }
 
    inline void setScale(const double s) { _scale = s; }
 
    inline double getScale(void) const { return _scale; }
 
    inline void set_MAXITER(const int i) { MAXITER = i; }
 
    int verbose;
 
    double time_step;
 
    int save_period;
 
    bool recenter;
 
    Nodes::index recentering_direction;
 
    double threshold;
 
    int scalfmmNbTh;
 
    bool V_file;
 
    bool spin_acc;
 
    std::string sMx;
 
    std::string sMy;
 
    std::string sMz;
 
    std::string sM;
 
    std::string sBx;
 
    std::string sBy;
 
    std::string sBz;
 
    std::string sB;
 
    std::string sB_space;
 
    std::string sB_time;
 
    std::string restoreFileName;
 
    double initial_time = NAN;
 
    double DUMAX;  // 0.1 for magnetostatic simulations; 0.02 for the dynamics
 
    double TOL;
 
    int MAXITER;
 
    std::vector<Tetra::prm> paramTetra;
 
    template <typename T>
    int findRegionIdx(const std::string &name ) const
        {
        typename std::vector<T>::const_iterator containerBegin, containerEnd;
        if constexpr (std::is_same_v<T,Tetra::prm>)
            { containerBegin = paramTetra.begin(); containerEnd = paramTetra.end(); }
        else if constexpr (std::is_same_v<T,Triangle::prm>)
            { containerBegin = paramTriangle.begin(); containerEnd = paramTriangle.end(); }
 
        typename std::vector<T>::const_iterator result = std::find_if(
                containerBegin, containerEnd,
                [name] (const T &p) { return (p.regName == name);} );
        int idx(-2);
        if (result == containerEnd)
            { idx = -1; }
        else
            { idx = std::distance(containerBegin, result); }
        return idx;
        }
 
    std::vector<Triangle::prm> paramTriangle;
 
    std::string r_path_output_dir;
 
    std::vector<std::string> evol_columns;
 
    double tf;
 
    double dt_min;
 
    double dt_max;
 
    inline mag_exprType getMagType() const
        {
        if (mag_parser.parameter_count() < 4)
            { return POSITION_ONLY; }
        else
            { return POSITION_AND_REGIONS; }
        }
 
    inline Eigen::Vector3d getMagnetization(const Eigen::Ref<const Eigen::Vector3d> p) const
        {
        Eigen::Vector3d tmp = mag_parser.get_vector(p);
        tmp.normalize();
        return tmp;
        }
 
    inline Eigen::Vector3d getMagnetization(const Eigen::Ref<const Eigen::Vector3d> p,
            const std::vector<std::string> &regions) const
        {
        Eigen::Vector3d tmp = mag_parser.get_vector(p, regions);
        tmp.normalize();
        return tmp;
        }
 
    inline Eigen::Vector3d getField(const double t_val) const
        {
        // If this is not meaningful, return a vector of NAN.
        if (field_type != RtoR3)
            { return {NAN, NAN, NAN}; }
 
        return (field_parser.get_vector(t_val))/mu0;
        }
 
    inline field_exprType getFieldType(void) const
        { return field_type; }
 
    inline Eigen::Vector3d getFieldSpace(const Eigen::Ref<const Eigen::Vector3d> p) const
        { return field_space_parser.get_vector(p); }
 
    inline double getFieldTime(const double t_val) const
        { return (field_time_parser.get_scalar(t_val))/mu0; }
 
private:
    using MetadataItem = std::pair<std::string, std::string>;  
    std::vector<MetadataItem> userMetadata;  
    int precision;               
    std::string fileDisplayName; 
    double _scale;               
    std::string simName;         
    std::string pbName;          
    ExpressionParser mag_parser;     
    field_exprType field_type;
 
    ExpressionParser field_parser;
 
    // field(x,y,z,t) = field_time(t) * field_space(x,y,z) with field_time R -> R
    // and field_space R³->R³
    ExpressionParser field_time_parser;
 
    ExpressionParser field_space_parser;
 
    std::ostringstream commonMetadata() const;
 
    const bool NORMALIZE = true;
 
    std::vector<std::pair<std::string, std::string>> settings_checksums;
 
    std::pair<std::string, std::string> mesh_checksum;
    };
 
#endif /* settings_h */