GenerateOpalSimulation.h

Go to the documentation of this file.

#ifndef __GENERATE_SIMULATION_H__
#define __GENERATE_SIMULATION_H__

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <map>
#include <cstdlib>

#include <vector>
#include <boost/algorithm/string.hpp>

#include "Util/OptPilotException.h"

class GenerateOpalSimulation {

public:

    GenerateOpalSimulation(std::string tmplFile, std::string varDictionary,
                           std::map<std::string,std::string> userValues) {
        varDictionary_ = varDictionary;
        tmplFile_ = tmplFile;

        // some variables need to be scaled
        scaleVars_.insert(std::pair<std::string, double>("GUNSOLB", 1.));

        // add user values and then fill using the data file without
        // overwriting user values..
        dictionary_.insert(userValues.begin(),userValues.end());
        fillDictionary();
    }

    ~GenerateOpalSimulation() {
        dictionary_.clear();
        scaleVars_.clear();
    }

    void writeInputFile(std::string outputFile) {

        std::ifstream infile(tmplFile_.c_str());
        std::ostringstream outdata;
        outdata.precision(15);

        while(infile.good()) {
            std::string line;
            std::getline(infile, line, '\n');

            //XXX doing the inverse would be better
            std::map<std::string, std::string>::iterator itr = dictionary_.begin();
            for(;itr != dictionary_.end(); itr++) {
                size_t pos = line.find("_" + itr->first + "_");
                while(pos != std::string::npos) {
                    line.replace(pos, itr->first.length() + 2, itr->second);
                    pos = line.find("_" + itr->first + "_");
                }
            }

            outdata << line << std::endl;
        }
        infile.close();

        // ensure the contents are written to disk
        std::ofstream outfile(outputFile.c_str());
        outfile.precision(15);
        outfile << outdata.str();
        outfile.flush();
        outfile.rdbuf()->pubsync();

        outfile.close();
    }


private:

    std::string tmplFile_;
    std::string varDictionary_;
    std::map<std::string, std::string> dictionary_;
    std::map<std::string, double> scaleVars_;

    void fillDictionary() {

        std::ifstream infile;
        infile.open(varDictionary_.c_str(), std::ifstream::in);

        char tmp[1024];
        unsigned int line_nr = 0;
        while(infile.good()) {
            std::fill_n(tmp, 1024, '\0');
            infile.getline(tmp, 1024);
            line_nr++;
            if(tmp[0] != '#') {
                std::string stmp(tmp);
                boost::trim(stmp);
                if(stmp.size() == 0)
                    continue;

                std::vector<std::string> all_strings;
                boost::split(all_strings, stmp,
                             boost::is_any_of("\r\n\v\f\t "),
                             boost::token_compress_on);

                if(all_strings.size() < 2) {
                    std::cout << "PROBLEM with the following line "
                              << "(at least name and value required)!"
                              << std::endl;
                    std::cout << stmp << std::endl;
                    std::ostringstream ex;
                    ex << "Invalid data file on line " << line_nr;
                    throw OptPilotException(
                            "GenerateOpalSimulation::fillDictionary()",
                            ex.str());
                }

                std::string varname = all_strings[0];
                std::string value   = all_strings[1];
                scale(varname, &value);
                dictionary_.insert(std::pair<std::string, std::string>(
                            varname, value));
            }
        }

        infile.close();
    }


    void scale(std::string name, std::string *value) {
        if(scaleVars_.count(name) > 0) {
            std::istringstream instr(*value);
            double val;
            instr >> val;
            val *= scaleVars_[name];

            // we keep values as strings, since we have to write them to
            // output streams anyways..
            std::ostringstream of;
            of << val;
            *value = of.str();
        }
    }

};

#endif