feellgoodSettings.h

Go to the documentation of this file.

#ifndef feellgoodSettings_h
#define feellgoodSettings_h
 
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <vector>
 
#include <yaml-cpp/yaml.h>
 
#include "expression_parser.h"
#include "facette.h"
#include "tetra.h"
#include "time_integration.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(std::string filename);
 
    inline int getPrecision(void) const { return precision; }
 
    inline std::string getFileDisplayName(void) const { return fileDisplayName; }
 
    inline void setFileDisplayName(std::string _s) { fileDisplayName = _s; }
 
    inline void setPbName(std::string str) { pbName = str; }
 
    inline std::string getPbName(void) const { return pbName; }
 
    inline void setSimName(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(int i) { MAXITER = i; }
 
    bool withTsv;
 
    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;
 
    inline int findTetraRegionIdx(const std::string &name ) const
        {
        std::vector<Tetra::prm>::const_iterator result =
                std::find_if(paramTetra.begin(), paramTetra.end(),
                             [name](Tetra::prm const &p) { return (p.regName == name); });
 
        int idx(-2);
        if (result == paramTetra.end())
            {
            idx = -1;
            }
        else
            {
            idx = std::distance(paramTetra.begin(), result);
            }
        return idx;
        };
 
    std::vector<Facette::prm> paramFacette;
 
    std::string r_path_output_dir;
 
    std::vector<std::string> evol_columns;
 
    double tf;
 
    double dt_min;
 
    double dt_max;
 
    inline int findFacetteRegionIdx(const std::string name ) const
        {
        std::vector<Facette::prm>::const_iterator result =
                std::find_if(paramFacette.begin(), paramFacette.end(),
                             [name](Facette::prm const &p) { return (p.regName == name); });
        int idx(-2);
 
        if (result == paramFacette.end())
            {
            idx = -1;
            }
        else
            {
            idx = std::distance(paramFacette.begin(), result);
            }
        return idx;
        };
 
    inline mag_exprType getMagType() const
        {
        if (mag_parser.parameter_count() < 4) return POSITION_ONLY;
        return POSITION_AND_REGIONS;
        }
 
    inline Eigen::Vector3d getMagnetization(const Eigen::Ref<Eigen::Vector3d> p) const
        {
        Eigen::Vector3d tmp = mag_parser.get_vector(p);
        tmp.normalize();
        return tmp;
        }
 
    inline Eigen::Vector3d getMagnetization(const Eigen::Ref<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<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;
    };
 
#endif /* feellgoodSettings_h */