MonteCarlo Class Reference

A class for Monte Carlo. More...

#include <MonteCarlo.h>

Collaboration diagram for MonteCarlo:

Detailed Description

A class for Monte Carlo.

Author

HEPfit Collaboration

Copyright

GNU General Public License

This class is responsible for the MCMC runs using the MCMCEngine class together with input parameters from the InputParser class. The Monte Carlo mode is the default run mode if the –noMC flag is not specified. The settings for the Monte Carlo run can be fixed in in the format specified in the MonteCarlo.conf file, the name of this configuration file should be specified as the second argument to the executable.

Definition at line 35 of file MonteCarlo.h.

Public Member Functions
void	addCustomObservableType (const std::string name, boost::function< Observable *() > funct)
std::map< std::string, BCH1D * >	getHistograms1D () const
std::map< std::string, BCH2D * >	getHistograms2D () const
	MonteCarlo (ModelFactory &ModelF, ThObsFactory &ThObsF, const std::string &ModelConf_i, const std::string &MonteCarloConf_i, const std::string &OutFile_i, const std::string &JobTag_i)
	Constructor. More...
void	Run (const int rank)
	This member is responsible for setting the Monte Carlo run parameters and conducting the Monte Carlo run including initiating all output generation. More...
void	TestRun (int rank)
	The default destructor. More...

Private Member Functions
void	ReadPreRunData (std::string file)

Private Attributes
bool	CalculateNormalization
	< Flag for calculating the evidence. More...
std::vector< CorrelatedGaussianObservables >	CGO
	Vector for the Correlated Gaussian Observables defined in SomeModel.conf. More...
std::vector< CorrelatedGaussianParameters >	CGP
	Vector for the Correlated Gaussian Parameters defined in SomeModel.conf. More...
bool	checkrun
	A check to make sure TestRun()and Run() are not called consecutively. More...
bool	FindModeWithMinuit
	Flag for using Minuit libraries. More...
std::string	JobTag
	String for the optional JobTag argument to be passes to the executable. More...
MonteCarloEngine	MCEngine
	An object of the MonteCarloEngine class. More...
std::string	MCMCConf
	String for the name of the MonteCarlo.conf file. More...
std::string	ModelConf
	String for the name of the SomeModel.conf file. More...
std::string	ModelName
	The name of the model. More...
std::vector< ModelParameter >	ModPars
	Vector for the model parameters defined in SomeModel.conf. More...
InputParser	myInputParser
	An object of the InputParser class. More...
double	normalization
	A variable to store the evidence of a model. More...
boost::ptr_vector< Observable >	Obs
	Vector for the observables defined in SomeModel.conf. More...
std::vector< Observable2D >	Obs2D
	Vector for the Observables2D defined in SomeModel.conf. More...
std::string	ObsDirName
	String for the output directory name. More...
std::string	OutFile
	String for the name of the output root file without the .root extension. More...
bool	PrintAllMarginalized
	Flag for printing all Marginalized distributions to be passed on to the BAT routines. More...
bool	PrintCorrelationMatrix
	Flag for printing the correlation matrix. More...
bool	PrintKnowledgeUpdatePlots
	Flag for printing plots to compare prior vs. posterior knowledge of parameters. More...
bool	PrintParameterPlot
	Flag for printing the overview parameter plots. More...
bool	WritePreRunData
	Flag for printing the overview parameter plots. More...

Constructor & Destructor Documentation

MonteCarlo::MonteCarlo	(	ModelFactory &	ModelF,
		ThObsFactory &	ThObsF,
		const std::string &	ModelConf_i,
		const std::string &	MonteCarloConf_i,
		const std::string &	OutFile_i,
		const std::string &	JobTag_i
	)

Constructor.

The default constructor sets the names of the configuration files and the names of the output root file and specific output directory if a job ID is specified as an argument to the executable. The constructor also sets the default values of some flags related to the Monte Carlo run. The boolean flags (FindModeWithMinuit, PrintAllMarginalized, PrintCorrelationMatrix, PrintKnowledgeUpdatePlots, PrintParameterPlot) attain their run time values after the MonteCarlo.conf file is parsed by MonteCarlo::Run().

Parameters

[in]	ModelF
[in]	ThObsF
[in]	ModelConf_i	the name of the input configuration file for the model name, the model parameters and observables to be calculated (Observables, Observables2D, Model Parameters vs. Observables and Correlated Gaussian Observables)
[in]	MonteCarloConf_i	the name of the Monte Carlo configuration file that specifies the parameters of the Monte Carlo run like no. of chains, no. of pre run iterations etc.
[in]	OutFile_i	the name of the root output file to be given without the .root extention
[in]	JobTag_i	optional job tag that might be specified

Definition at line 26 of file MonteCarlo.cpp.

: myInputParser(ModelF, ThObsF), MCEngine(ModPars, Obs, Obs2D, CGO, CGP) {
    ModelConf = ModelConf_i;
    MCMCConf = MonteCarloConf_i;
    JobTag = JobTag_i;
    if (OutFile_i.compare("") == 0) OutFile = "MCout" + JobTag + ".root";
    else OutFile = OutFile_i + JobTag + ".root";
    ObsDirName = "Observables" + JobTag;
    FindModeWithMinuit = false;
    CalculateNormalization = false;
    PrintAllMarginalized = false;
    PrintCorrelationMatrix = false;
    PrintKnowledgeUpdatePlots = false;
    PrintParameterPlot = false;
    WritePreRunData = false;
    checkrun = false;
    normalization = 0.;
}

Member Function Documentation

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

Definition at line 489 of file MonteCarlo.cpp.

                                                                                                  {
    myInputParser.addCustomObservableType(name, funct);
}

std::map<std::string, BCH1D * > MonteCarlo::getHistograms1D ( ) const

inline

Definition at line 142 of file MonteCarlo.h.

    {
        return MCEngine.getHistograms1D();
    }

std::map<std::string, BCH2D * > MonteCarlo::getHistograms2D ( ) const

inline

Definition at line 147 of file MonteCarlo.h.

    {
        return MCEngine.getHistograms2D();
    }

void MonteCarlo::ReadPreRunData ( std::string  file )

private

Definition at line 456 of file MonteCarlo.cpp.

{
    std::ifstream ifile(file.c_str());
    if (!ifile.is_open())
        throw std::runtime_error("\nMonteCarlo::ReadPreRunData ERROR: " + file + " does not exist.\n");
    std::string line;
    bool IsEOF = false;
    std::vector<double> mode;
    std::vector<double> scale;
    do {
        IsEOF = getline(ifile, line).eof();
        if (line.empty())
            continue;   
        boost::char_separator<char> sep(" ");
        boost::tokenizer<boost::char_separator<char> > tok(line, sep);
        boost::tokenizer<boost::char_separator<char> >::iterator beg = tok.begin();
        ++beg;
        mode.push_back(atof((*beg).c_str()));
        ++beg;
        scale.push_back(atof((*beg).c_str()));
    } while (!IsEOF);
    if (mode.size() != MCEngine.GetNParameters())
        throw std::runtime_error("\nMonteCarlo::ReadPreRunData ERROR: wrong data size.\n");
    std::vector<double> mode_all;
    std::vector<double> scale_all;
    for (unsigned int i = 0; i < MCEngine.MCMCGetNChains(); i++){
        mode_all.insert(mode_all.end(), mode.begin(), mode.end());
        scale_all.insert(scale_all.end(), scale.begin(), scale.end());
    }
    MCEngine.MCMCSetInitialPositions(mode_all);
    MCEngine.MCMCSetTrialFunctionScaleFactor(scale_all);
}

void MonteCarlo::Run

(

const int

rank

)

This member is responsible for setting the Monte Carlo run parameters and conducting the Monte Carlo run including initiating all output generation.

The algorithm implemented by this member is as follows:

• Initiate InputParser::ReadParameters() which read the SomeModel.conf file for setting the model parameters and the observables to be generated. This call also passes on the name of the model to the private member ModelName.

• Map the model parameter mean values with the map DP and calculate buffsize which can be used for implementing MPI runs. The variable buffsize is incremented only for those model parameters that are varied in the Monte Carlo run.

• Initiate the model using the map DP checking for consistency between required model parameters and the ones supplied in the SomeModel.conf file

• Set the model name and initialize the MCMC engine with the model at hand.

• For MPI runs, send the evaluates of the loglikelihood for the prerun to the slave processes (rank != 0)

• The master in an MPI run or the process in a serial run then parses the MonterCarlo.conf file to read the parameters for the Monte Carlo run.

• The root output file is handed over to the object out of type BCModelOutput and some BAT options are set for the log and output histograms.

• The MCMC is run and all the out put is generated according to the options set in the MonteCarlo.conf file.

• For a MPI run, the final call to the MPI class prepares the processes for finalizing.

The details for BCSummaryTool, BCLog, BCAux and BCModelOutput can be found in the BAT website. These are used mainly to generate logs and output.

The details of the object MCEngine of type MonteCarloEngine which overloads the BCEngineMCMC class can be found in our documentation of the former class.

Parameters

[in]

rank

= MPI::COMM_WORLD.Get_rank(), specifies the rank of the process. This carries a non zero value only when the executable is compiled with the parallelized version of BAT and run as parallel processes with MPI.

Definition at line 108 of file MonteCarlo.cpp.

                                   {
    if (checkrun == true) {
        if (rank == 0) throw std::runtime_error("ERROR: MonteCarlo::Run() cannot be called after calling MonteCarlo::TestRun().\n");
        else sleep(2);
    } else {
        checkrun = true;
    }

    try {

        /* set model parameters */
        ModelName = myInputParser.ReadParameters(ModelConf, rank, ModPars, Obs, Obs2D, CGO, CGP);
        int buffsize = 0;
        std::map<std::string, double> DP;
        for (std::vector<ModelParameter>::iterator it = ModPars.begin(); it < ModPars.end(); it++) {
            if (it->geterrg() > 0. || it->geterrf() > 0.)
                buffsize++;
            if (it->IsCorrelated()) {
                for (unsigned int i = 0; i < CGP.size(); i++) {
                    if (CGP[i].getName().compare(it->getCgp_name()) == 0) {
                        std::string index = it->getname().substr(CGP[i].getName().size());
                        long int lindex = strtol(index.c_str(), NULL, 10);
                        if (lindex > 0)
                            DP[CGP[i].getPar(lindex - 1).getname()] = CGP[i].getPar(lindex - 1).getave();
                        else {
                            std::stringstream out;
                            out << it->getname();
                            throw std::runtime_error("MonteCarlo::Run(): " + out.str() + "seems to be part of a CorrelatedGaussianParameters object, but I couldn't find the corresponding object");
                        }
                    }
                }
            } else
                DP[it->getname()] = it->getave();
        }
        if (buffsize == 0){
            if (rank == 0) throw std::runtime_error("No parameters being varied. Aborting MCMC run.\n");
            else sleep(2);
        }
        buffsize++;
        if (!myInputParser.getModel()->Init(DP)){
            if (rank == 0) throw std::runtime_error("\nERROR: Model cannot be initialization.\n");
            else sleep(2);
        }

        if (rank == 0) std::cout << std::endl << "Running in MonteCarlo mode...\n" << std::endl;

        /* create a directory for outputs */
        if (rank == 0) {
            FileStat_t info;
            if (gSystem->GetPathInfo(ObsDirName.c_str(), info) != 0) {
                if (gSystem->MakeDirectory(ObsDirName.c_str()) == 0)
                    std::cout << ObsDirName << " directory has been created." << std::endl;
                else
                    throw std::runtime_error("ERROR: " + ObsDirName + " directory cannot be created.\n");
            }
        }

        MCEngine.SetName(ModelName.c_str());
        MCEngine.Initialize(myInputParser.getModel());

#ifdef _MPI
        double *recvbuff = new double[buffsize];
#endif

        if (rank != 0) {
#ifdef _MPI
            double **sendbuff = new double*[1];
            sendbuff[0] = new double[1];

            std::vector<double> pars;
            int obsbuffsize = Obs.size() + 2 * Obs2D.size();
            for (std::vector<CorrelatedGaussianObservables>::iterator it1 = CGO.begin(); it1 < CGO.end(); it1++)
                obsbuffsize += it1->getObs().size();

            while (true) {
                MPI::COMM_WORLD.Scatter(sendbuff[0], buffsize, MPI::DOUBLE,
                        recvbuff, buffsize, MPI::DOUBLE, 0);

                if (recvbuff[0] == 0.) { // do nothing and return ll
                    double ll = log(0.);
                    MPI::COMM_WORLD.Gather(&ll, 1, MPI::DOUBLE, sendbuff[0], 1, MPI::DOUBLE, 0);
                } else if (recvbuff[0] == 1.) { //compute log likelihood
                    pars.assign(recvbuff + 1, recvbuff + buffsize);
                    double ll = MCEngine.LogEval(pars);
                    MPI::COMM_WORLD.Gather(&ll, 1, MPI::DOUBLE, sendbuff[0], 1, MPI::DOUBLE, 0);
                } else if (recvbuff[0] == 2.) { // compute observables
                    double sbuff[obsbuffsize];
                    std::map<std::string, double> DPars;
                    pars.assign(recvbuff + 1, recvbuff + buffsize);
                    MCEngine.setDParsFromParameters(pars,DPars);
                    myInputParser.getModel()->Update(DPars);

                    int k = 0;
                    for (boost::ptr_vector<Observable>::iterator it = Obs.begin(); it < Obs.end(); it++) {
                        sbuff[k++] = it->computeTheoryValue();
                    }
                    for (std::vector<Observable2D>::iterator it = Obs2D.begin(); it < Obs2D.end(); it++) {
                        sbuff[k++] = it->computeTheoryValue();
                        sbuff[k++] = it->computeTheoryValue2();
                    }

                    for (std::vector<CorrelatedGaussianObservables>::iterator it1 = CGO.begin(); it1 < CGO.end(); it1++) {
                        std::vector<Observable> pino(it1->getObs());
                        for (std::vector<Observable>::iterator it = pino.begin(); it != pino.end(); ++it)
                            sbuff[k++] = it->computeTheoryValue();
                    }
                    MPI::COMM_WORLD.Gather(sbuff, obsbuffsize, MPI::DOUBLE, sendbuff[0], obsbuffsize, MPI::DOUBLE, 0);
                } else if (recvbuff[0] == 3.) { // do not compute observables, but gather the buffer
                    double sbuff[obsbuffsize];
                    MPI::COMM_WORLD.Gather(sbuff, obsbuffsize, MPI::DOUBLE, sendbuff[0], obsbuffsize, MPI::DOUBLE, 0);
                } else if (recvbuff[0] == -1.)
                    break;
                else {
                    std::cout << "recvbuff = " << recvbuff[0] << " rank " << rank << std::endl;
                    throw "MonteCarlo::Run(): error in MPI message!\n";
                }
            }
            delete sendbuff[0];
            delete [] sendbuff;
#endif
        } else {

            bool writechains = false;
            std::cout << std::endl;
            std::cout << std::endl;
            if (ModPars.size() > 0) std::cout << ModPars.size() << " parameters defined." << std::endl;
            if (Obs.size() > 0) std::cout << Obs.size() << " observables defined." << std::endl;
            if (Obs2D.size() > 0) std::cout << Obs2D.size() << " 2D observables defined." << std::endl;
            if (CGO.size() > 0) std::cout << CGO.size() << " correlated gaussian observables defined";
            if (CGO.size() == 0)
                std::cout << "." << std::endl;
            else
                std::cout << ":" << std::endl;
            for (std::vector<CorrelatedGaussianObservables>::iterator it1 = CGO.begin();
                    it1 != CGO.end(); ++it1)
                std::cout << "  " << it1->getName() << " containing "
                << it1->getObs().size() << " observables." << std::endl;
            //MonteCarlo configuration parser
            std::ifstream ifile(MCMCConf.c_str());
            if (!ifile.is_open())
                throw std::runtime_error("\nERROR: " + MCMCConf + " does not exist. Make sure to specify a valid Monte Carlo configuration file.\n");
            std::string line;
            bool IsEOF = false;
            do {
                IsEOF = getline(ifile, line).eof();
                if (*line.rbegin() == '\r') line.erase(line.length() - 1); // for CR+LF
                if (line.empty() || line.at(0) == '#')
                    continue;
                boost::char_separator<char> sep(" \t");
                boost::tokenizer<boost::char_separator<char> > tok(line, sep);
                boost::tokenizer<boost::char_separator<char> >::iterator beg = tok.begin();
                if (beg->compare("NChains") == 0) {
                    ++beg;
                    MCEngine.setNChains(atoi((*beg).c_str()));
                } else if (beg->compare("PrerunMaxIter") == 0) {
                    ++beg;
                    MCEngine.MCMCSetNIterationsMax(atoi((*beg).c_str()));
                } else if (beg->compare("NIterationsUpdateMax") == 0) {
                    ++beg;
                    MCEngine.MCMCSetNIterationsUpdateMax(atoi((*beg).c_str()));
                } else if (beg->compare("Seed") == 0) {
                    ++beg;
                    int seed = atoi((*beg).c_str());
                    if (seed != 0)
                        MCEngine.MCMCSetRandomSeed(seed);
                } else if (beg->compare("Iterations") == 0) {
                    ++beg;
                    MCEngine.MCMCSetNIterationsRun(atoi((*beg).c_str()));
                } else if (beg->compare("MinimumEfficiency") == 0) {
                    ++beg;
                    MCEngine.MCMCSetMinimumEfficiency(atof((*beg).c_str()));
                } else if (beg->compare("WriteChain") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0)
                        writechains = true;
                } else if (beg->compare("FindModeWithMinuit") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0) {
                        FindModeWithMinuit = true;
                    }
                } else if (beg->compare("CalculateNormalization") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0) {
                        CalculateNormalization = true;
                    }
                } else if (beg->compare("PrintAllMarginalized") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0) {
                        PrintAllMarginalized = true;
                    }
                } else if (beg->compare("PrintCorrelationMatrix") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0) {
                        PrintCorrelationMatrix = true;
                    }
                } else if (beg->compare("PrintKnowledgeUpdatePlots") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0) {
                        PrintKnowledgeUpdatePlots = true;
                    }
                } else if (beg->compare("PrintParameterPlot") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0) {
                        PrintParameterPlot = true;
                    }
                } else if (beg->compare("WritePreRunData") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0) {
                        WritePreRunData = true;
                    }
                } else if (beg->compare("ReadPreRunData") == 0) {
                    ++beg;
                    ReadPreRunData(*beg);
                } else if (beg->compare("OrderParameters") == 0) {
                    ++beg;
                    if (beg->compare("false") == 0) {
                        MCEngine.MCMCSetFlagOrderParameters(false);
                    }
                } else if (beg->compare("StatOverFlow") == 0) {
                    ++beg;
                    if (beg->compare("true") == 0) MCEngine.setHistogramOverFlow(true);
                    if (beg->compare("false") == 0) MCEngine.setHistogramOverFlow(false);
                    else throw std::runtime_error("\nERROR: Wrong value in MonteCarlo config file for keyword StatOverFlow. It can be either true or false.\n");
                } else
                    throw std::runtime_error("\nERROR: Wrong keyword in MonteCarlo config file: " + *beg + "\n Make sure to specify a valid Monte Carlo configuration file.\n");
            } while (!IsEOF);

            BCModelOutput out(&MCEngine, OutFile.c_str());
            if (writechains) {
                out.WriteMarkovChain(true);
                MCEngine.AddChains();
            }

            // set nicer style for drawing than the ROOT default
            BCAux::SetStyle();

            // open log file
            BCLog::OpenLog(("log" + JobTag + ".txt").c_str());
            BCLog::SetLogLevel(BCLog::debug);

            // run the MCMC and marginalize w.r.t. to all parameters
            MCEngine.BCIntegrate::SetNbins(NBINSMODELPARS);
            MCEngine.SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
            std::time_t ti = std::time(NULL);
            char mbstr[100];
            if (std::strftime(mbstr, sizeof(mbstr), "%H:%M:%S %d/%m/%y ", std::localtime(&ti))) 
                std::cout << "MCMC Run started at " <<  mbstr << std::endl; 
            MCEngine.MarginalizeAll();
            std::time_t tf = std::time(NULL);
            if (std::strftime(mbstr, sizeof(mbstr), "%H:%M:%S %d/%m/%y ", std::localtime(&tf))) 
                std::cout << "MCMC Run ended at " <<  mbstr << std::endl; 

            // find mode using the best fit parameters as start values
            if (FindModeWithMinuit)
                MCEngine.FindMode(MCEngine.GetBestFitParameters());

            if (CalculateNormalization) normalization = MCEngine.computeNormalization();

            // draw all marginalized distributions into a pdf file
            if (PrintAllMarginalized)
                MCEngine.PrintAllMarginalized(("MonteCarlo_plots" + JobTag + ".pdf").c_str());

            // print results of the analysis into a text file
            MCEngine.PrintResults(("MonteCarlo_results" + JobTag + ".txt").c_str());

            // print histograms
            MCEngine.PrintHistogram(out, ObsDirName);

            BCSummaryTool myBCSummaryTool(&MCEngine);

            // draw the correlation matrix into a pdf file
            if (PrintCorrelationMatrix)
                myBCSummaryTool.PrintCorrelationMatrix(("ParamCorrelations" + JobTag + ".pdf").c_str());

            // print the correlation matrix into a tex file
            if (PrintCorrelationMatrix)
                MCEngine.PrintCorrelationMatrix(("ParamCorrelations" + JobTag + ".tex").c_str());

            // print comparisons of the prior knowledge to the posterior knowledge 
            // for all parameters into a pdf file
            if (PrintKnowledgeUpdatePlots)
                myBCSummaryTool.PrintKnowledgeUpdatePlots(("ParamUpdate" + JobTag + ".pdf").c_str());

            // draw an overview plot of the parameters into a pdf file
            if (PrintParameterPlot)
                myBCSummaryTool.PrintParameterPlot(("ParamSummary" + JobTag + ".pdf").c_str());

            // print a LaTeX table of the parameters into a tex file
            //myBCSummaryTool.PrintParameterLatex(("ParamSummary" + JobTag + ".tex").c_str());

            out.WriteMarginalizedDistributions();
            out.FillAnalysisTree();
            out.Close();

            // print logs for the histograms of the observables into a text file
            std::ofstream outHistoLog;
            outHistoLog.open((ObsDirName + "/HistoLog" + JobTag + ".txt").c_str(), std::ios::out);
            outHistoLog << MCEngine.getHistoLog();
            outHistoLog.close();

            // print statistics for the theory values of the observables into a text file
            std::ofstream outStatLog;
            outStatLog.open((ObsDirName + "/Statistics" + JobTag + ".txt").c_str(), std::ios::out);
            if (CalculateNormalization) outStatLog << "Normalization for " << ModelName.c_str() << ": " << normalization << "\n" << std::endl;
            outStatLog << MCEngine.computeStatistics();
            outStatLog.close();

            // print global mode and scale factors for the 1st chain into a text file
            if (WritePreRunData) {
                std::ofstream outPreRun;
                outPreRun.open(("PreRun" + JobTag + ".txt").c_str(), std::ios::out);
                outPreRun << MCEngine.writePreRunData();
                outPreRun.close();
            }

            /* Number of events */
            std::stringstream ss;
            ss << "Number of used events: " << MCEngine.getNumOfUsedEvents();
            BCLog::OutSummary(ss.str().c_str());
            ss.str("");
            ss << "Number of discarded events: " << MCEngine.getNumOfDiscardedEvents();
            BCLog::OutSummary(ss.str().c_str());

            // close log file
            BCLog::CloseLog();

#ifdef _MPI
            double ** sendbuff = new double *[MCEngine.procnum];
            sendbuff[0] = new double[MCEngine.procnum * buffsize];
            for (int il = 1; il < MCEngine.procnum; il++) {
                sendbuff[il] = sendbuff[il - 1] + buffsize;
                sendbuff[il][0] = -1.; //Exit command
            }
            MPI::COMM_WORLD.Scatter(sendbuff[0], buffsize, MPI::DOUBLE,
                    recvbuff, buffsize, MPI::DOUBLE, 0);
            delete sendbuff[0];
            delete [] sendbuff;
#endif
        }
#ifdef _MPI
        delete [] recvbuff;
#endif
    } catch (std::string message) {
        std::cerr << message << std::endl;
        exit(EXIT_FAILURE);
    }
}

void MonteCarlo::TestRun

(

int

rank

)

The default destructor.

This member is used for test runa to generate a single event

The values of the parameters that are used to generate the single event is the average value passed from the SomeModel.conf file.

The algorithm implemented by this member is as follows:

• Initiate InputParser::ReadParameters() which read the SomeModel.conf file for setting the model parameters and the observables to be generated. This call also passes on the name of the model to the private member ModelName.

• Map the model parameter mean values with the map DP and calculate buffsize which can be used for implementing MPI runs. The variable buffsize is incremented only for those model parameters that are varied in the Monte Carlo run.

• Initiate the model using the map DP checking for consistency between required model parameters and the ones supplied in the SomeModel.conf file

• Generate a single set of observables and correlated Gaussian observables as listed in the SomeModel.conf file. The output is passes to the standard output.

Parameters

[in]

rank

= MPI::COMM_WORLD.Get_rank(), specifies the rank of the process. This carries a non zero value only when the executable is compiled with the parallelized version of BAT and run as parallel processes with MPI.

Definition at line 52 of file MonteCarlo.cpp.

                                 {
    if (checkrun == true) {
        if (rank == 0) throw std::runtime_error("ERROR: MonteCarlo::TestRun() cannot be called after calling MonteCarlo::Run().\n");
        else sleep (2);
    } else {
        checkrun = true;
    }

    if (rank == 0) {
        ModelName = myInputParser.ReadParameters(ModelConf, rank, ModPars, Obs, Obs2D, CGO, CGP);
        std::map<std::string, double> DP;
        if (Obs.size() == 0 && CGO.size() == 0) throw std::runtime_error("\nMonteCarlo::TestRun(): No observables or correlated Gaussian observables defined in SomeModel.conf file\n");

        for (std::vector<ModelParameter>::iterator it = ModPars.begin(); it < ModPars.end(); it++) {
            if (it->IsCorrelated()) {
                for (unsigned int i = 0; i < CGP.size(); i++) {
                    if (CGP[i].getName().compare(it->getCgp_name()) == 0) {
                        std::string index = it->getname().substr(CGP[i].getName().size());
                        long int lindex = strtol(index.c_str(), NULL, 10);
                        if (lindex > 0)
                            DP[CGP[i].getPar(lindex - 1).getname()] = CGP[i].getPar(lindex - 1).getave();
                        else {
                            std::stringstream out;
                            out << it->getname();
                            throw std::runtime_error("MonteCarlo::Run(): " + out.str() + "seems to be part of a CorrelatedGaussianParameters object, but I couldn't find the corresponding object");
                        }
                    }
                }
            } else
                DP[it->getname()] = it->getave();
        }

        if (!myInputParser.getModel()->Init(DP)) {
            if (rank == 0) throw std::runtime_error("ERROR: Parameter(s) missing in model initialization. \n");
            else sleep (2);
        }

        if (Obs.size() > 0) std::cout << "\nOservables: \n" << std::endl;
        for (boost::ptr_vector<Observable>::iterator it = Obs.begin(); it < Obs.end(); it++) {
            double th = it->computeTheoryValue();
            std::cout << it->getName() << " = " << th << std::endl;
        }

        if (CGO.size() > 0) std::cout << "\nCorrelated Gaussian Oservables: \n" << std::endl;
        for (std::vector<CorrelatedGaussianObservables>::iterator it1 = CGO.begin(); it1 < CGO.end(); it1++) {
            std::cout << it1->getName() << ":" << std::endl;
            std::vector<Observable> ObsInCGO = it1->getObs();
            for (std::vector<Observable>::iterator it2 = ObsInCGO.begin(); it2 < ObsInCGO.end(); it2++) {
                double th = it2->computeTheoryValue();
                std::cout << it2->getName() << " = " << th << std::endl;
            }
            std::cout << std::endl;
        }
    }
}

Member Data Documentation

bool MonteCarlo::CalculateNormalization

private

< Flag for calculating the evidence.

Definition at line 169 of file MonteCarlo.h.

std::vector<CorrelatedGaussianObservables> MonteCarlo::CGO

private

Vector for the Correlated Gaussian Observables defined in SomeModel.conf.

Definition at line 161 of file MonteCarlo.h.

std::vector<CorrelatedGaussianParameters> MonteCarlo::CGP

private

Vector for the Correlated Gaussian Parameters defined in SomeModel.conf.

Definition at line 162 of file MonteCarlo.h.

bool MonteCarlo::checkrun

private

A check to make sure TestRun()and Run() are not called consecutively.

Definition at line 175 of file MonteCarlo.h.

bool MonteCarlo::FindModeWithMinuit

private

Flag for using Minuit libraries.

Definition at line 168 of file MonteCarlo.h.

std::string MonteCarlo::JobTag

private

String for the optional JobTag argument to be passes to the executable.

Definition at line 166 of file MonteCarlo.h.

MonteCarloEngine MonteCarlo::MCEngine

private

An object of the MonteCarloEngine class.

Definition at line 157 of file MonteCarlo.h.

std::string MonteCarlo::MCMCConf

private

String for the name of the MonteCarlo.conf file.

Definition at line 164 of file MonteCarlo.h.

std::string MonteCarlo::ModelConf

private

String for the name of the SomeModel.conf file.

Definition at line 163 of file MonteCarlo.h.

std::string MonteCarlo::ModelName

private

The name of the model.

Definition at line 155 of file MonteCarlo.h.

std::vector<ModelParameter> MonteCarlo::ModPars

private

Vector for the model parameters defined in SomeModel.conf.

Definition at line 158 of file MonteCarlo.h.

InputParser MonteCarlo::myInputParser

private

An object of the InputParser class.

Definition at line 156 of file MonteCarlo.h.

double MonteCarlo::normalization

private

A variable to store the evidence of a model.

Definition at line 176 of file MonteCarlo.h.

boost::ptr_vector<Observable> MonteCarlo::Obs

private

Vector for the observables defined in SomeModel.conf.

Definition at line 159 of file MonteCarlo.h.

std::vector<Observable2D> MonteCarlo::Obs2D

private

Vector for the Observables2D defined in SomeModel.conf.

Definition at line 160 of file MonteCarlo.h.

std::string MonteCarlo::ObsDirName

private

String for the output directory name.

Definition at line 167 of file MonteCarlo.h.

std::string MonteCarlo::OutFile

private

String for the name of the output root file without the .root extension.

Definition at line 165 of file MonteCarlo.h.

bool MonteCarlo::PrintAllMarginalized

private

Flag for printing all Marginalized distributions to be passed on to the BAT routines.

Definition at line 170 of file MonteCarlo.h.

bool MonteCarlo::PrintCorrelationMatrix

private

Flag for printing the correlation matrix.

Definition at line 171 of file MonteCarlo.h.

bool MonteCarlo::PrintKnowledgeUpdatePlots

private

Flag for printing plots to compare prior vs. posterior knowledge of parameters.

Definition at line 172 of file MonteCarlo.h.

bool MonteCarlo::PrintParameterPlot

private

Flag for printing the overview parameter plots.

Definition at line 173 of file MonteCarlo.h.

bool MonteCarlo::WritePreRunData

private

Flag for printing the overview parameter plots.

Definition at line 174 of file MonteCarlo.h.

---

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

• MonteCarlo.h
• MonteCarlo.cpp