InputParser.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef INPUTPARSER_H
#define INPUTPARSER_H
 
#include "ThObsFactory.h"
#include "ModelFactory.h"
#include "Observable.h"
#include "Observable2D.h"
#include "CorrelatedGaussianObservables.h"
#include "CorrelatedGaussianParameters.h"
#include "HiggsObservable.h"
#include "ThObservable.h"
#include "ModelParameter.h"
#include "StandardModel.h"
#include <iostream>
#include <fstream>
#include <istream>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/function.hpp>
#include <string>
 
class InputParser {
public:
    
    InputParser(ModelFactory& ModF, ThObsFactory& ObsF);
    
    InputParser(const InputParser& orig);
    
    virtual ~InputParser();
    
//    CorrelatedGaussianObservables ParseCGO(boost::ptr_vector<Observable>& Observables, std::ifstream& ifile, boost::tokenizer<boost::char_separator<char> >::iterator& beg);
    
    std::string ReadParameters(const std::string filename_i,
                               const int rank,
                               std::vector<ModelParameter>& ModelPars,
                               boost::ptr_vector<Observable>& Observables,
                               std::vector<Observable2D>& Observables2D,
                               std::vector<CorrelatedGaussianObservables>& CGO,
                               std::vector<CorrelatedGaussianParameters>& CGP);
 
    StandardModel* getModel() const
    {
        return myModel;
    }
    
    const ThObsFactory& getObsFactory() const
    {
        return myObsFactory;
    }
 
    ModelFactory& getModelFactory() const {
        return myModelFactory;
    }
    
    void addCustomObservableType(const std::string name, boost::function<Observable*() > funct);
    
    Observable * CreateObservableType(const std::string& name) const;
    
    void setModel(StandardModel* myModel_i){
        myModel = myModel_i;
    }
    
private:
    StandardModel* myModel;
    ModelFactory& myModelFactory;
    ThObsFactory& myObsFactory;
    std::string modname;
    bool modelset;
    std::map <std::string, boost::tuple<bool, std::string, int> > checkDuplicateParameter;
    std::string modeldefinedinfile;
    //std::map<std::string, boost::function<InputParser*(ModelFactory&, ThObsFactory&) > > customParserMap;
    std::map<std::string, boost::function<Observable* ()> > customObservableTypeMap;
    //std::map<std::string, std::string> ObservableToParsermap;
    int lineNo;
    std::string filename;
    int rank;
    std::string filepath;
    std::string line;
    bool IsEOF;
};
 
#endif  /* INPUTPARSER_H */