A class for providing access to the computation of observables without a Monte Carlo run. More...

#include <ComputeObservables.h>

Detailed Description

A class for providing access to the computation of observables without a Monte Carlo run.

Author: HEPfit Collaboration

Copyright: GNU General Public License

This class can be used to create an object that takes a map of model parameters that need to be varied in the analysis and passes out a map of the observables that it is told to compute.

Definition at line 35 of file ComputeObservables.h.

Public Member Functions
void	addCustomObservableType (const std::string name, boost::function< Observable *() > funct)
	A method to add a user defined observable with a user defined likelihood. More...

void	AddObservable (std::string ObsName)
	A method to remove an observable from the list of observables. More...

std::map< std::string, double >	compute (std::map< std::string, double > DP)
	The method used to compute observables. More...

	ComputeObservables (ModelFactory &ModelF, ThObsFactory &ThObsF, const std::string &ModelConf_i, const int rank_i=0)
	Constructor. More...

	ComputeObservables (ModelFactory &ModelF, ThObsFactory &ThObsF, const std::string &ModelName_i, std::map< std::string, double > DPars_i, std::map< std::string, std::string > DFlags_i, const int rank_i=0)
	Constructor. More...

StandardModel *	getModel ()
	A get method return the pointer to the model. More...

std::map< std::string, double >	getObservables ()
	A method to get the map of observables. More...

std::map< std::string, double >	getParameters ()
	A method to get the map of parameters. More...

void	RemoveObservable (std::string ObsName)
	A method to add an observable to the list of observables. More...

void	setFlags (std::map< std::string, std::string > DFlags_i)
	This method sets the necessary flag for the requested model. More...

virtual	~ComputeObservables ()
	The default destructor. More...

Private Attributes
std::vector< CorrelatedGaussianObservables >	CGO

std::vector< CorrelatedGaussianParameters >	CGP

std::map< std::string, std::string >	DFlags
	Map of the model flags to be passed to Model. More...

std::map< std::string, double >	DObs
	Map of the observables to be computed. More...

std::map< std::string, double >	DPars
	Map of the parameters to be passed to Model. More...

std::map< std::string, ThObservable * >	DThObs

StandardModel *	Mod
	Pointer to an object of the class StandardModel. More...

std::string	ModelName
	Name of the Model to be used. More...

std::vector< ModelParameter >	ModPars

InputParser	myInputParser
	An object of the InputParser class. More...

boost::ptr_vector< Observable >	Obs

std::vector< Observable2D >	Obs2D

std::vector< std::string >	paraNames
	The vector of allowed parameter names. More...

const int	rank
	< Rank of the MPI process. Set to 0 for serial run. More...

std::vector< std::string >	unknownParameters

Constructor & Destructor Documentation

◆ ComputeObservables() [1/2]

ComputeObservables::ComputeObservables	(	ModelFactory &	ModelF,
		ThObsFactory &	ThObsF,
		const std::string &	ModelConf_i,
		const int	rank_i = `0`
	)

Constructor.

This constructor passes the name of the SomeModel.conf file. It is to be used to compute observables using of a SomeModel.conf file to initialize the mandatory parameters.

Parameters

[in]	ModelF
[in]	ThObsF
[in]	ModelConf_i	the name of the input configuration file for the model name,
[in]	rank_i	the rank of the process in a MPI run (set to 0 for serial run) the model parameters and observables to be calculated

Definition at line 14 of file ComputeObservables.cpp.

: myInputParser(ModelF, ThObsF),
  rank(rank_i)
{
 
    std::string ModelName = myInputParser.ReadParameters(ModelConf_i, rank, ModPars, Obs, Obs2D, CGO, CGP);
    std::map<std::string, double> DP;
    for (std::vector<ModelParameter>::iterator it = ModPars.begin(); it < ModPars.end(); it++) {
        DP[it->getname()] = it->getave();
        paraNames.push_back(it->getname());
    }
    DPars = DP;
    
    for (boost::ptr_vector<Observable>::iterator it = Obs.begin(); it < Obs.end(); it++) {
        DObs.insert(std::pair<std::string, double> (it->getThname() , 0.));
        DThObs.insert(std::pair<std::string, ThObservable*> (it->getThname() , it->getTho()));
    }
    for (std::vector<CorrelatedGaussianObservables>::iterator it1 = CGO.begin(); it1 < CGO.end(); it1++) {
        std::vector<Observable> ObsInCGO = it1->getObs();
        for (std::vector<Observable>::iterator it2 = ObsInCGO.begin(); it2 < ObsInCGO.end(); it2++) {
            DObs.insert(std::pair<std::string, double> (it2->getThname() , 0.));
            DThObs.insert(std::pair<std::string, ThObservable*> (it2->getThname() , it2->getTho()));
        }
    }
    
    Mod = myInputParser.getModel();
    if (!Mod->Init(DP)) {
        if (myInputParser.getModel()->getmissingModelParameters().size() > 0) {
            std::cout << "\nPlease set the following parameters in the model configuration files:\n" << std::endl;
            std::vector<std::string> missingParameters = myInputParser.getModel()->getmissingModelParameters(); // Store the result in a variable to avoid dangling pointer warning
            for (std::vector<std::string>::iterator it = missingParameters.begin(); it != missingParameters.end(); it++) {
                std::cout << "ModelParameter\t" << *it << std::endl;
            }
            std::cout << std::endl;
            missingParameters.clear();
        }
        throw std::runtime_error("ERROR: Parameter(s) missing in model initialization.\n");
    }
    
    unknownParameters = Mod->getUnknownParameters();
    if (unknownParameters.size() > 0 && rank == 0) {
        std::cout << "\n" << std::endl;
        for (std::vector<std::string>::iterator it = unknownParameters.begin(); it != unknownParameters.end(); it++)
            std::cout << "WARNING: unknown parameter " << *it << " not added." << std::endl;
    }
}

◆ ComputeObservables() [2/2]

ComputeObservables::ComputeObservables	(	ModelFactory &	ModelF,
		ThObsFactory &	ThObsF,
		const std::string &	ModelName_i,
		std::map< std::string, double >	DPars_i,
		std::map< std::string, std::string >	DFlags_i,
		const int	rank_i = `0`
	)

Constructor.

This constructor passes the model name and model parameters. It is to be used to compute observables without the use of a SomeModel.conf file.

Parameters

[in]	ModelF
[in]	ThObsF
[in]	ModelName_i	the name of the model being used
[in]	DPars_i	the mandatory parameters of the model being used
[in]	rank_i	the rank of the process in a MPI run (set to 0 for serial run)

Definition at line 62 of file ComputeObservables.cpp.

: ModelName(ModelName_i),
  myInputParser(ModelF, ThObsF),
  rank(rank_i)
{
    for (std::map<std::string, double>::iterator it = DPars_i.begin(); it != DPars_i.end(); it++) {
        paraNames.push_back(it->first);
    }
    Mod = myInputParser.getModelFactory().CreateModel(ModelName);
    Mod->setModelName(ModelName);
    Mod->InitializeModel();
    if (Mod->IsModelInitialized()) {
        if (rank == 0) std::cout << "\nModel Initialized: " << ModelName << std::endl;
    } else {
        throw std::runtime_error("\nERROR: " + ModelName + " not initialized successfully.\n");
    }
    setFlags(DFlags_i);
    if (!Mod->Init(DPars_i)) {
        if (myInputParser.getModel()->getmissingModelParameters().size() > 0) {
            std::cout << "\nPlease set the following parameters in the model configuration files:\n" << std::endl;
            std::vector<std::string> missingParameters = myInputParser.getModel()->getmissingModelParameters(); // Store the result in a variable to avoid dangling pointer warning
             for (std::vector<std::string>::iterator it = missingParameters.begin(); it != missingParameters.end(); it++) {
                std::cout << "ModelParameter\t" << *it << std::endl;
            }
            std::cout << std::endl;
            myInputParser.getModel()->getmissingModelParameters().clear();
        }
        throw std::runtime_error("\nERROR: " + ModelName + " cannot be initialized.\n");
    }
   
    unknownParameters = Mod->getUnknownParameters();
    if (unknownParameters.size() > 0 && rank == 0) {
        std::cout << "\n" << std::endl;
        for (std::vector<std::string>::iterator it = unknownParameters.begin(); it != unknownParameters.end(); it++)
            std::cout << "WARNING: unknown parameter " << *it << " not added to MCMC" << std::endl;
    }
}

◆ ~ComputeObservables()

ComputeObservables::~ComputeObservables ( )

virtual

The default destructor.

Definition at line 102 of file ComputeObservables.cpp.

{
    Obs.clear();
    boost::ptr_vector<Observable>().swap(Obs);
    Mod = NULL;
}

Member Function Documentation

◆ addCustomObservableType()

void ComputeObservables::addCustomObservableType	(	const std::string	name,
		boost::function< Observable *() >	funct
	)

A method to add a user defined observable with a user defined likelihood.

Parameters

[in] a function of the type observable

Definition at line 155 of file ComputeObservables.cpp.

                                                                                                         {
        myInputParser.addCustomObservableType(name, funct);
}

◆ AddObservable()

void ComputeObservables::AddObservable ( std::string ObsName )

A method to remove an observable from the list of observables.

Parameters

[in] ObsName the name of the observable to be removed

Definition at line 149 of file ComputeObservables.cpp.

{
    DThObs[ObsName] = myInputParser.getObsFactory().CreateThMethod(ObsName, *Mod);
    DObs.insert(std::pair<std::string, double> (ObsName , 0.));
}

◆ compute()

std::map< std::string, double > ComputeObservables::compute ( std::map< std::string, double > DP )

The method used to compute observables.

Parameters

[in] DP the map of parameters being varied

Definition at line 124 of file ComputeObservables.cpp.

{
    if (DP != DPars)
        for (std::map<std::string, double>::iterator it = DP.begin(); it != DP.end(); it++) {
            if(!(std::find(paraNames.begin(), paraNames.end(), it->first) != paraNames.end()))
                throw std::runtime_error("\nERROR: Incorrect parameter name " + it->first + " passed to ComputeObservable");
        }
    DPars = DP;
    Mod->Update(DPars);
    for (std::map<std::string, double>::iterator it = DObs.begin(); it != DObs.end(); it++) {
        DObs[it->first] = DThObs[it->first]->computeThValue();
    }
    return(DObs);
}

◆ getModel()

StandardModel * ComputeObservables::getModel ( )

inline

A get method return the pointer to the model.

Returns: the pointer to the model

Definition at line 123 of file ComputeObservables.h.

    {
        return Mod;    
    }

◆ getObservables()

std::map< std::string, double > ComputeObservables::getObservables ( )

inline

A method to get the map of observables.

Returns: the map of observables

Definition at line 99 of file ComputeObservables.h.

    {
        return (DObs);
    };

◆ getParameters()

std::map< std::string, double > ComputeObservables::getParameters ( )

inline

A method to get the map of parameters.

Returns: the map of parameters

Definition at line 108 of file ComputeObservables.h.

    {
        return (DPars);
    };

◆ RemoveObservable()

void ComputeObservables::RemoveObservable ( std::string ObsName )

A method to add an observable to the list of observables.

Parameters

[in] ObsName the name of the observable to be added

Definition at line 139 of file ComputeObservables.cpp.

{
    if(DObs.find(ObsName) == DObs.end()) 
        throw std::runtime_error("\nERROR: Observable cannot be removed since it has not been added.\n");
    DObs.erase(ObsName);
    if(DThObs.find(ObsName) == DThObs.end()) 
        throw std::runtime_error("\nERROR: ThObservable cannot be removed since it has not been added.\n");
    DThObs.erase(ObsName);
}

◆ setFlags()

void ComputeObservables::setFlags ( std::map< std::string, std::string > DFlags_i )

This method sets the necessary flag for the requested model.

Parameters

[in] DFlags_i the flags for the model being used

Definition at line 109 of file ComputeObservables.cpp.

{
    for (std::map<std::string, std::string>::iterator it = DFlags_i.begin(); it != DFlags_i.end(); it++) {
        if (!(boost::iequals(it->second, "true")) && !(boost::iequals(it->second, "false")) && !Mod->setFlagStr(it->first, it->second)) {
            throw std::runtime_error("ERROR: setFlagStr error for " + it->first);
        } else if (boost::iequals(it->second, "true") && !Mod->setFlag(it->first, 1)) {
            throw std::runtime_error("ERROR: setFlag error for " + it->first);
        } else if (boost::iequals(it->second, "false") && !Mod->setFlag(it->first, 0)) {
            throw std::runtime_error("ERROR: setFlag error for " + it->first);
        } else {
            if (rank == 0) std::cout << "set flag " << it->first << " = " << it->second << std::endl;
        }
    }
}

Member Data Documentation

◆ CGO

std::vector<CorrelatedGaussianObservables> ComputeObservables::CGO

private

Definition at line 143 of file ComputeObservables.h.

◆ CGP

std::vector<CorrelatedGaussianParameters> ComputeObservables::CGP

private

Definition at line 144 of file ComputeObservables.h.

◆ DFlags

std::map<std::string, std::string> ComputeObservables::DFlags

private

Map of the model flags to be passed to Model.

Definition at line 135 of file ComputeObservables.h.

◆ DObs

std::map<std::string, double> ComputeObservables::DObs

private

Map of the observables to be computed.

Definition at line 134 of file ComputeObservables.h.

◆ DPars

std::map<std::string, double> ComputeObservables::DPars

private

Map of the parameters to be passed to Model.

Definition at line 133 of file ComputeObservables.h.

◆ DThObs

std::map<std::string, ThObservable*> ComputeObservables::DThObs

private

Definition at line 137 of file ComputeObservables.h.

◆ Mod

StandardModel* ComputeObservables::Mod

private

Pointer to an object of the class StandardModel.

Definition at line 131 of file ComputeObservables.h.

◆ ModelName

std::string ComputeObservables::ModelName

private

Name of the Model to be used.

Definition at line 130 of file ComputeObservables.h.

◆ ModPars

std::vector<ModelParameter> ComputeObservables::ModPars

private

Definition at line 140 of file ComputeObservables.h.

◆ myInputParser

InputParser ComputeObservables::myInputParser

private

An object of the InputParser class.

Definition at line 132 of file ComputeObservables.h.

◆ Obs

boost::ptr_vector<Observable> ComputeObservables::Obs

private

Definition at line 141 of file ComputeObservables.h.

◆ Obs2D

std::vector<Observable2D> ComputeObservables::Obs2D

private

Definition at line 142 of file ComputeObservables.h.

◆ paraNames

std::vector<std::string> ComputeObservables::paraNames

private

The vector of allowed parameter names.

Definition at line 136 of file ComputeObservables.h.

◆ rank

const int ComputeObservables::rank

private

< Rank of the MPI process. Set to 0 for serial run.

Definition at line 138 of file ComputeObservables.h.

◆ unknownParameters

std::vector<std::string> ComputeObservables::unknownParameters

private

Definition at line 139 of file ComputeObservables.h.

The documentation for this class was generated from the following files:

Detailed Description

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ ComputeObservables() [1/2]

◆ ComputeObservables() [2/2]

◆ ~ComputeObservables()

Member Function Documentation

◆ addCustomObservableType()

◆ AddObservable()

◆ compute()

◆ getModel()

◆ getObservables()

◆ getParameters()

◆ RemoveObservable()

◆ setFlags()

Member Data Documentation

◆ CGO

◆ CGP

◆ DFlags

◆ DObs

◆ DPars

◆ DThObs

◆ Mod

◆ ModelName

◆ ModPars

◆ myInputParser

◆ Obs

◆ Obs2D

◆ paraNames

◆ rank

◆ unknownParameters