fsi_input.cpp

#ifdef Q_OS_WIN32
#include <QCoreApplication>
#include <QSettings>
#endif

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <algorithm>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <cstdio>
#include <iostream>
#ifndef _WIN32
#include <error.h>
#include <unistd.h>
#include <libgen.h>
#endif
#include <cstring>

#include "pugixml.hpp"
#include <PMsolver.h>

#define ATTR(varname) doc.child("settings").append_attribute(varname)
#define TOLOWER(name) transform(name.begin(), name.end(), name.begin(), ::tolower);

using namespace std;

typedef map<string,string> key_val_map_t;

#ifdef _WIN32
extern string Xsettings_file;
string Xsettings_file;
#endif

const double pi = 3.14159265358979323846;

char* get_opt(char ** begin, char ** end, const string & option) {
    char ** itr = find(begin, end, option);
    if (itr != end && ++itr != end) {
        return *itr;
    }
    return nullptr;
}

bool has_opt(char** begin, char** end, const string& option) {
    return find(begin, end, option) != end;
}

/*!
 * \brief fsi_convert - convert user input according to parameter
 * \param varname
 * \param val
 * \return
 */
static double fsi_convert(const char *varname, const double val) {
    if (strcmp(FSI_NAME_twist, varname) == 0 ||
        strcmp(FSI_NAME_AOA, varname) == 0 ||
        strcmp(FSI_NAME_roll, varname) == 0 ||
        strcmp(FSI_NAME_sweep, varname) == 0) {

        return val * pi / 180.0; // convert degrees to radians
    }
    return val;
}

/*!
 * \brief set_fsi_parm - set an int variable according to command line, environment, settings file, or otherwise default
 * \param envvarname - assumed same name used environment, settings file, command line
 * \param default_val
 * \param argc
 * \param argv
 * \return
 */
int set_fsi_parm(const char *varname,
                 const int default_val,
                 key_val_map_t &key_val_map,
                 pugi::xml_node &doc,
                 int argc, char **argv) {

    assert(varname != nullptr);

    // check command line
    int outval;

    string opt("--");
    opt += varname;
    if (argc > 0 && has_opt(argv, argv + argc, opt)) {
        const char *argstring = get_opt(argv, argv + argc, opt);
        if (argstring == nullptr) {
            cerr << "Warning: parsing error for command line parameter:" << opt << endl;
        } else {
            if (1 == sscanf(argstring, "%d", &outval)) {
                ATTR(varname) = argstring;
                return outval;
            } else {
                cerr << "Warning: parsing error for command line parameter:" << opt << " value:" << argstring <<endl;
            }
        }
    }

    // check for environment variable
    string envvarname = ENV_PM_PREFACE;
    envvarname += varname;
#ifdef Q_OS_WIN32
    QString qsval;
    bool ok;
    qsval = qEnvironmentVariable(envvarname.c_str());
    outval = qsval.toInt(&ok);
    if (ok) {
        ATTR(varname) = qsval.toStdString().c_str();
        return outval;
    }
#else
    if (getenv(envvarname.c_str()) != nullptr) {
        if (1 == sscanf(getenv(envvarname.c_str()), "%d", &outval)) {
            ATTR(varname) = to_string(outval).c_str();
            return outval;
        } else {
            cerr << "Warning: parsing error for environment variable:" << varname <<
                    " value:" <<  getenv(envvarname.c_str()) << endl;
        }
    }
#endif

    // check for value specified in ini file
    string svarname(varname);
    key_val_map_t::iterator it = key_val_map.find(svarname);
    if (it != key_val_map.end()) {
        try {
            outval = stoi(key_val_map[svarname]);
            ATTR(varname) = key_val_map[svarname].c_str();
            return outval;
        }
        catch (exception& e) {
            cerr << "exception caught while parsing integer from " << svarname <<
                    "from ini file. Exception: " << e.what() << '\n';
        }
    }
#ifdef Q_OS_WIN32
    // check setting in registry if no settings file
    if (Xsettings_file.length() == 0) {
        QSettings qsettings;
        qsval = qsettings.value(varname).toString();
        outval = qsval.toInt(&ok);
        if (ok) {
            ATTR(varname) = qsval.toStdString().c_str();
            return outval;
        }
    }
#endif
    return default_val;
}

/*!
 * \brief set_fsi_parm - set an int variable according to command line, environment, settings file, or otherwise default
 * \param envvarname - assumed same name used environment, settings file, command line
 * \param default_val
 * \param argc
 * \param argv
 * \return
 */
double set_fsi_parm(const char *varname,
                 const double default_val,
                 key_val_map_t &key_val_map,
                 pugi::xml_node &doc,
                 int argc, char **argv) {

    assert(varname != nullptr);

    // check command line
    double outval;

    string opt("--");
    opt += varname;
    if (argc > 0 && has_opt(argv, argv + argc, opt)) {
        const char *argstring = get_opt(argv, argv + argc, opt);
        if (argstring == nullptr) {
            cerr << "Warning: parsing error for command line parameter:" << opt << endl;
        } else {
            if (1 == sscanf(argstring, "%lf", &outval)) {
                ATTR(varname) = argstring;
                return fsi_convert(varname, outval);  // do any conversions and return
            } else {
                cerr << "Warning: parsing error for command line parameter:" << opt << " value:" << argstring <<endl;
            }
        }
    }

    // check for environment variable
    string envvarname = ENV_PM_PREFACE;
    envvarname += varname;
#ifdef Q_OS_WIN32
    QString qsval;
    bool ok;
    qsval = qEnvironmentVariable(envvarname.c_str());
    outval = qsval.toDouble(&ok);
    if (ok) {
        ATTR(varname) = qsval.toStdString().c_str();
        return fsi_convert(varname, outval);  // do any conversions and return
    }
#else
    if (getenv(envvarname.c_str()) != nullptr) {
        if (1 == sscanf(getenv(envvarname.c_str()), "%lf", &outval)) {
            ATTR(varname) = to_string(outval).c_str();
            return fsi_convert(varname, outval);  // do any conversions and return
        } else {
            cerr << "Warning: parsing error for environment variable:" << varname <<
                    " value:" <<  getenv(envvarname.c_str()) << endl;
        }
    }
#endif

    // check for value specified in ini file
    string svarname(varname);
    key_val_map_t::iterator it = key_val_map.find(svarname);
    if (it != key_val_map.end()) {
        try {
            outval = stod(key_val_map[svarname]);
            ATTR(varname) = key_val_map[svarname].c_str();
            return fsi_convert(varname, outval);  // do any conversions and return
        }
        catch (exception& e) {
            cerr << "exception caught while parsing integer from " << svarname <<
                    "from ini file. Exception: " << e.what() << '\n';
        }
    }
#ifdef Q_OS_WIN32
    // check setting in registry if no settings file
    if (Xsettings_file.length() == 0) {
        QSettings qsettings;
        qsval = qsettings.value(varname).toString();
        outval = qsval.toDouble(&ok);
        if (ok) {
            ATTR(varname) = qsval.toStdString().c_str();
            return fsi_convert(varname, outval);  // do any conversions and return
        }
    }
#endif

    return default_val;
}

void set_fsi_parm(string &outstring,
                  const char *varname,
                  const char *default_val,
                  key_val_map_t &key_val_map,
                  pugi::xml_node &doc,
                  int argc, char **argv) {

    assert(varname != nullptr);
    assert(default_val != nullptr);

    // check command line
    string opt("--");
    opt += varname;
    if (argc > 0 && has_opt(argv, argv + argc, opt)) {
        outstring = get_opt(argv, argv + argc, opt);
        ATTR(varname) = outstring.c_str();
        return;
    }

    // check for environment variable
    string envvarname = ENV_PM_PREFACE;
    envvarname += varname;
#ifdef Q_OS_WIN32
    QString qsval;
    qsval = qEnvironmentVariable(envvarname.c_str());
    if (!qsval.isNull() && !qsval.isEmpty()) {
        outstring = qsval.toStdString();
        ATTR(varname) = outstring.c_str();
        return;
    }
#else
    if (getenv(envvarname.c_str()) != nullptr) {
        outstring = getenv(envvarname.c_str());
        cerr << "Using settings from environment variable " << envvarname << " found: " << outstring << endl;
        ATTR(varname) = outstring.c_str();
        return;
    }
#endif
    // the only string we get from the settings file is the XML filename
    // check settings file

#ifdef Q_OS_WIN32
    // use Qt to parse settings file on win32
    if (Xsettings_file.length() > 0) {
        QSettings qsettings(QString::fromStdString(Xsettings_file), QSettings::NativeFormat);
        qsval = qsettings.value(varname).toString();
        QString checked_var(varname);
        checked_var += "_checked";
        QString checked_val = qsettings.value(checked_var).toString();
        if (checked_val == "2" && !qsval.isNull() && !qsval.isEmpty()) {
            outstring = qsval.toStdString();
            ATTR(varname) = outstring.c_str();
            return;
        }
    }
    // check win32 registry
    QSettings qsettings;
    qsval = qsettings.value(varname).toString();
    QString checked_var(varname);
    checked_var += "_checked";
    QString checked_val = qsettings.value(checked_var).toString();
    if (checked_val == "2" && !qsval.isNull() && !qsval.isEmpty()) {
        outstring = qsval.toStdString();
        ATTR(varname) = outstring.c_str();
        return;
    }
#else
    if (key_val_map.find(varname) != key_val_map.end()) {  // found
        // see if there is a "_checked" entry to validate or invalidate the value
        string checked_varname(varname);
        checked_varname += "_checked";
        if (key_val_map.find(checked_varname) == key_val_map.end() ||  // found no validation
            key_val_map[checked_varname] == "2") {  // if box was checked
                outstring = key_val_map[varname];
                ATTR(varname) = key_val_map[varname].c_str();
                return;
        }
        // explicitly unchecked - ignore value and fall through
    }
#endif

    outstring = default_val;
}

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
#pragma GCC diagnostic pop

bool parse_ini(istream &is, key_val_map_t &key_val_map) {
    string key, val;
    string ini_line;

    while (is) {
        getline (is,ini_line);
        trim(ini_line);
        if (ini_line[0] == '#') continue;
        size_t found = ini_line.find('[');
        if (found != ini_line.npos) {
            size_t found_val=ini_line.find(']');
            if (found_val != ini_line.npos) {
                continue;
            }
            cerr << "Unterminated section: " << ini_line << endl;
            continue;
        }
        found = ini_line.find('=');
        if (found == ini_line.npos) continue;
        key = ini_line.substr(0, found);
        rtrim(key);
        if (key.size() == 0) continue;
        //TOLOWER(key);  M vs. m - case cannot be ignored
        if (++found >= ini_line.length()) continue;
        val = ini_line.substr(found);
        trim(val);
        if (key.length() > 0 && val.length() > 0) {
              key_val_map[key] = val;
        }
    }
    for (key_val_map_t::iterator itr=key_val_map.begin(); itr!=key_val_map.end(); ++itr)
          cerr << itr->first << " => " << itr->second << '\n';
    return true;
}

/*!
 * \brief parse_ini - parse a simplified .ini format file
 * \param fn - filename
 * \param key_val_map - C++ map with key/value pairs
 * \return
 *
 * Note: Qt provides this, but kept in case of need to eliminate Qt dependency
 *   Qt provides windows-supported reading environment variables (getenv deprecated)
 */
int parse_ini(const char *fn, key_val_map_t &key_val_map) {
    filebuf fb;
    if (!fb.open(fn, ios::in)) {
        cerr << "Settings file open failure on " << fn << endl;
        return -1;
    }
    cerr << "Opened " << fn << endl;
    istream is(&fb);
    bool ret = parse_ini(is, key_val_map);
    fb.close();
    return ret == true;
} 
#ifndef _WIN32
/*!
 * \brief write_test - prove that data file will be writable to directory
 * \param fn - output data file name
 */
void write_test(const string fn) {
    string tfn(fn);
    tfn += "WRITETEST";
    char lcl[1024];
    strncpy(lcl, tfn.c_str(), sizeof(lcl) - 1);
    struct stat sts;
    int retst = stat(dirname(lcl), &sts);
    if (retst == -1) {
        if (mkdir(dirname(lcl), 0744) != 0) {
            error(-1, errno, "Could not create directory for data file : %s", lcl);
        }
        stat(dirname(lcl), &sts);
    }
    if (!S_ISDIR(sts.st_mode)) {
        cerr << lcl << " for data file " << tfn << " must be a directory" << endl;
        exit(-1);
    }
    int fd = creat(tfn.c_str(), 0744);
    if (fd == -1) {
        error(-1, errno, "Could not create test data file: %s", tfn.c_str());
    }
    close(fd);
    unlink(tfn.c_str());
}
#endif
#ifdef DO_BOOST
#include <boost/program_options.hpp>
using namespace boost::program_options;
void boost_options(const int argc, char **argv) {
    try {
        options_description desc {"Options"};
        desc.add_options()
                ("help,h", "Help screen")
                ("pi", value<float>()->default_value(3.14f), "Pi");
                //("age", value<int>()->notifier(on_age), "Age");

        variables_map vm;
        store(parse_command_line(argc, argv, desc), vm);
        notify(vm);
        parse_environment(desc, "PM_");

            if (vm.count("help"))
                  std::cout << desc << '\n';
                else if (vm.count("age"))
                  std::cout << "Age: " << vm["age"].as<int>() << '\n';
                else if (vm.count("pi"))
                  std::cout << "Pi: " << vm["pi"].as<float>() << '\n';

    } catch (const boost::program_options::error &ex) {
        cerr << ex.what() << '\n';
    }

}
#endif

#ifndef _WIN32
#define SET(n) set_test(#n)
#define SETS(n) set_fsi_parm(n, FSI_NAME_##n, default_##n, key_val_map, doc, argc, argv)
void set_test(const char *name) {
    string a("FSI_PM_");
    a += name;
    cerr << "Setting " << a << "=" << name << endl;
    setenv(a.c_str(), "1", 1);
    //setenv(a.c_str(), name, 1);
}
void st() {
    cerr << "in st" << endl;
    SET(data_file_path);  // location of output file
    // defining global constants and wing geometry
    SET(taper);
    //%AR=5;                    // Aspect ratio of the wing
    SET(c);  // Root chord length in m
    SET(rho);  // Air density kg/m^3
    SET(twist);  // wing linear twist
    SET(span);  // Wing span
    SET(roll);  // roll angle of the wing
    SET(sweep);  // Sweep angle of the wing
    SET(T);  // wing thickness(t),
    SET(p);  // maximum thickness from cord(p)
    SET(M);  // mean camber(m)
    SET(m);  // chord-wise panels
    SET(n);  // span-wise panels
    SET(nts); // Number of time steps
    //const double Pinf = 101325.0;      // Free stream pressure in pasacal
    //const double alfa = 0.0;           // Angle of Attack
    //const double AOA = alfa * pi / 180.0;    // Angle of Attack
    SET(Q);  // freestream velocity
    //const double Mach = Q / 343.0;        // freestream mach number
    SET(dxw);  // wake shedding distance
    //const double xf = 0.4 * c;           //  Distance from leading edge to pitching axis in m.
    //const double default_ydist = span * 0.2;  //  Distance of wing root from flapping axis. in m.
    SET(ydist);  //  Distance of wing root from flapping axis. in m.
    SET(Omega_rpm);  //  rotation speed in rpm
    //const double default_omegax = Omega_rpm / 60.0 * 2.0 * pi;  // rotation speed in rad/s
    SET(omegax);  // rotation speed in rad/s
    SET(tspc);  // Number of time steps per cycle
    //const double default_ts = 60.0 / Omega_rpm / tspc;  // Time step
    SET(ts);  // Time step
    //const int ti = 0:ts:(nts-1)*ts;// time vector
    SET(workinc);
    SET(workfactor);
}
#endif