Model.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef MODEL_H
#define MODEL_H
 
#include <map>
#include <functional>
#include <string>
#include <vector>
 
class Model {
public:
 
    Model()
    {
        ModelInitialized = false;
        flagSUSYmodel = false;
        flagLinearized = false;
    };
 
    virtual ~Model()
    {
    };
 
    void setModelName(const std::string name)
    {
        this->name = name;
    }
 
    std::string getModelName() const
    {
        return name;
    }
 
    virtual bool Init(const std::map<std::string, double>& DPars) = 0;
 
    virtual bool PreUpdate() = 0;
 
    virtual bool Update(const std::map<std::string, double>& DPars) = 0;
 
    virtual bool PostUpdate() = 0;
 
    virtual bool CheckParameters(const std::map<std::string, double>& DPars) = 0;
 
    virtual bool setFlag(const std::string name, const bool value) = 0;
 
    virtual bool setFlagStr(const std::string name, const std::string value) = 0;
 
    virtual bool CheckFlags() const = 0;
 
    bool IsModelInitialized() const
    {
        return ModelInitialized;
    }
 
    void setModelInitialized(bool ModelInitialized)
    {
        this->ModelInitialized = ModelInitialized;
    }
 
    bool IsUpdateError() const
    {
        return UpdateError;
    }
 
    void setUpdateError(bool UpdateError)
    {
        this->UpdateError = UpdateError;
    }
 
    const double& getModelParam(std::string name) const
    {
        return ModelParamMap.at(name);
    }
 
    bool isModelParam(std::string name) const
    {
        return (ModelParamMap.find(name) != ModelParamMap.end());
    }
 
    void setModelSUSY(){
        flagSUSYmodel = true;
    }
    
    bool isModelSUSY() const{
        return flagSUSYmodel;
    }
    
    void setModelTHDM(){
        flagTHDMmodel = true;
    }
    
    bool isModelTHDM() const{
        return flagTHDMmodel;
    }
 
    void setModelGeneralTHDM(){
        flagGTHDMmodel = true;
    }
    
    bool isModelGeneralTHDM() const{
        return flagGTHDMmodel;
    }
 
    void setModelTHDMW(){
        flagTHDMWmodel = true;
    }
    
    bool isModelTHDMW() const{
        return flagTHDMWmodel;
    }
 
    void setModelGeorgiMachacek(){
        flagGMmodel = true;
    }
    
    bool isModelGeorgiMachacek() const{
        return flagGMmodel;
    }
 
    
    bool isModelLinearized() const{
        return flagLinearized;
    }
    
    void setModelLinearized(bool linearized = true){
        flagLinearized = linearized;
    }
 
    void setSliced(bool Sliced)
    {
        isSliced = Sliced;
    }
    
    void addMissingModelParameter(const std::string& missingParameterName) 
    {
        missingModelParameters.push_back(missingParameterName);
    }
    
    std::vector<std::string> getmissingModelParameters()
    {
        return missingModelParameters;
    }
    
    void raiseMissingModelParameterCount() 
    {
        missingModelParametersCount++;
    }
    
    unsigned int getMissingModelParametersCount()
    {
        return missingModelParametersCount;
    }
 
protected:
 
    bool UpdateError; 
 
    virtual void setParameter(const std::string name, const double& value) = 0;
    mutable std::map< std::string, std::reference_wrapper<const double> > ModelParamMap;
 
    bool isSliced; 
 
private:
    std::string name; 
    bool ModelInitialized; 
    bool flagSUSYmodel;
    bool flagTHDMmodel;
    bool flagGTHDMmodel;
    bool flagTHDMWmodel;
    bool flagGMmodel;
    bool flagLinearized; 
    unsigned int missingModelParametersCount = 0;
    std::vector<std::string> missingModelParameters;
 
};
 
#endif  /* MODEL_H */