EventGeneration

A module for generating events based on the ROOT random number generator. More...

Classes
class	GenerateEvent
	A class for generating events. More...

Functions
void	GenerateEvent::addCustomObservableType (const std::string name, boost::function< Observable *() > funct)
void	GenerateEvent::createDirectories ()
void	GenerateEvent::defineParameterDistributions ()
	The parameter distributions as specified in SomeModel.conf is defined here. More...
void	GenerateEvent::generate (int unsigned nIteration_i, int seed=0, bool weight_i=false)
	The method used to generate events and format output. More...
	GenerateEvent::GenerateEvent (ModelFactory &ModelF, ThObsFactory &ThObsF, const std::string &ModelConf_i, const std::string &OutDirName_i, const std::string &JobTag_i)
	Constructor. More...
void	GenerateEvent::generateRandomEvent (int iterationNo)
	This member generates random numbers for the parameters being varied in the model. The first set is always the central value of the parameter. More...
void	GenerateEvent::initModel ()
void	GenerateEvent::setDParsFromParameters (const std::vector< double > &parameters, std::map< std::string, double > &DPars_i)
virtual	GenerateEvent::~GenerateEvent ()
	The default destructor. More...

Variables
double **	GenerateEvent::buff
int **	GenerateEvent::buff_int
double **	GenerateEvent::buff_w
int	GenerateEvent::buffersize
std::vector< CorrelatedGaussianObservables >	GenerateEvent::CGO
	vector for the Correlated Gaussian Observables defined in SomeModel.conf. More...
std::string	GenerateEvent::CGODirName
	String for the name of the Correlated Gaussian Observables output directory. More...
std::map< std::string, boost::shared_ptr< std::ofstream > >	GenerateEvent::CGOOut
	Map of output stream for corellated Gaussian observables. More...
std::vector< CorrelatedGaussianParameters >	GenerateEvent::CGP
	vector for the Correlated Gaussian Parameters defined in SomeModel.conf. More...
std::map< std::string, TF1 * >	GenerateEvent::DDist
	Map of parameter distributions. More...
std::map< std::string, double >	GenerateEvent::DPars
	Map of parameters to be passed to Model(). More...
std::string	GenerateEvent::JobTag
	String for the optional JobTag argument to be passes to the executable. More...
StandardModel *	GenerateEvent::Mod
	Name of the model as defined in SomeModel.conf. More...
std::string	GenerateEvent::ModelConf
	String for the name of the SomeModel.conf file. More...
std::string	GenerateEvent::ModelName
std::vector< ModelParameter >	GenerateEvent::ModPars
	Vector for the model parameters defined in SomeModel.conf. More...
std::vector< ModelParameter >	GenerateEvent::ModParsVar
	Vector for the model parameters varied in SomeModel.conf. More...
InputParser	GenerateEvent::myInputParser
	An oject of the InputParser() class. More...
int	GenerateEvent::nameLen
int	GenerateEvent::nIteration
boost::ptr_vector< Observable >	GenerateEvent::Obs
	Vector for the observables defined in SomeModel.conf. More...
std::vector< Observable2D >	GenerateEvent::Obs2D
	Vector for the Observables2D defined in SomeModel.conf. More...
std::string	GenerateEvent::ObsDirName
	String for the name of the observables output directory. More...
std::map< std::string, boost::shared_ptr< std::ofstream > >	GenerateEvent::ObsOut
	Map of output stream for observables. More...
std::string	GenerateEvent::OldOutDirName
	String for the name of the backup output directory. More...
std::string	GenerateEvent::OutDirName
	String for the name of the output directory. More...
bool	GenerateEvent::outputTerm
	Flag to specify output stream storage. More...
std::string	GenerateEvent::ParsDirName
	String for the name of the parameters output directory. More...
std::map< std::string, boost::shared_ptr< std::ofstream > >	GenerateEvent::ParsOut
	Map of output stream for parameters. More...
int	GenerateEvent::positionID
char	GenerateEvent::processorName [MPI_MAX_PROCESSOR_NAME]
int	GenerateEvent::procnum
int	GenerateEvent::rank
double *	GenerateEvent::sendbuff
int *	GenerateEvent::sendbuff_int
double *	GenerateEvent::sendbuff_w
std::string	GenerateEvent::SMDebugDirName
	String for the name of the observables output directory. More...
std::ofstream	GenerateEvent::summary
std::string	GenerateEvent::SUSYDebugDirName
	String for the name of the Correlated Gaussian Observables output directory. More...
bool	GenerateEvent::weight

Detailed Description

A module for generating events based on the ROOT random number generator.

This module is for using the implementations of the observables without running a Markov Chain Monte Carlo. It allows generation of events based on the ROOT random number generator.

Function Documentation

addCustomObservableType()

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

Definition at line 505 of file GenerateEvent.cpp.

                                                                                                    {
        myInputParser.addCustomObservableType(name, funct);
}

createDirectories()

void GenerateEvent::createDirectories ( )

private

Definition at line 270 of file GenerateEvent.cpp.

{
    if (nIteration > 0 && outputTerm == 1){
        FileStat_t info;
        if (gSystem->GetPathInfo("GeneratedEvents", info) != 0) {
            gSystem->MakeDirectory("GeneratedEvents");
        }
        if (gSystem->GetPathInfo("GeneratedEvents/DELETED", info) != 0) {
            gSystem->MakeDirectory("GeneratedEvents/DELETED");
        }
        if (gSystem->GetPathInfo(OutDirName.c_str(), info) == 0){
            if (gSystem->GetPathInfo(OldOutDirName.c_str(), info) == 0){
                gSystem->Exec(("rm -rf " + OldOutDirName).c_str());
                std::cout << "\nWARNING: Removed " << OldOutDirName << std::endl;
            }
            gSystem->Exec(("mv -f " + OutDirName + " " + "GeneratedEvents/DELETED/").c_str());
            std::cout << "WARNING: " << OutDirName << " exists!\nWARNING: " << OutDirName <<" moved to " << OldOutDirName << "\n"<< std::endl;
        }
        gSystem->MakeDirectory(OutDirName.c_str());
        gSystem->MakeDirectory(ObsDirName.c_str());
        gSystem->MakeDirectory(CGODirName.c_str());
        gSystem->MakeDirectory(ParsDirName.c_str());
        
        if (outputTerm == 1){
            summary.open((OutDirName + "/Summary.txt").c_str(), std::ios::out);
            summary << "Model\t" << ModelName << "\n";
        }
        
        for (std::vector<ModelParameter>::iterator it = ModParsVar.begin(); it < ModParsVar.end(); it++) {
            ParsOut[it->getname()] = boost::make_shared<std::ofstream>((ParsDirName + "/" + it->getname() + ".txt").c_str(), std::ios::out);
            summary << "Parameter\t" << it->getname() << "\n";
        }
 
        for (boost::ptr_vector<Observable>::iterator it = Obs.begin(); it < Obs.end(); it++) {
            ObsOut[it->getName()] = boost::make_shared<std::ofstream>((ObsDirName + "/" + it->getName() + ".txt").c_str(), std::ios::out);
            if (outputTerm != 0 && it->getObsType().compare("HiggsObservable") == 0) {
                for (int i = 0; i < it->getNTheoryValues(); i++) (*ObsOut[it->getName()]) << std::setw(6) << std::left << "sigma(" << std::setw(1) << i << std::setw(3) << std::left <<")";
                (*ObsOut[it->getName()]) << std::setw(10) << std::left << "BR";
                for (int i = it->getNTheoryValues() + 1; i < it->getNTheoryValues() + 1 + it->getNChannels(); i++) (*ObsOut[it->getName()]) << std::setw(3) << std::left << "mu(" << std::setw(1) << i << std::setw(6) << std::left << ")";
                if (weight) (*ObsOut[it->getName()]) << std::setw(10) << std::left << "weight";
                (*ObsOut[it->getName()]) << std::endl;
            }
            summary << "Observable\t" << it->getName() << "\n";
        }
        for (std::vector<CorrelatedGaussianObservables>::iterator it = CGO.begin(); it < CGO.end(); it++){
            CGOOut[it->getName()] = boost::make_shared<std::ofstream>((CGODirName + "/" + it->getName() + ".txt").c_str(), std::ios::out);
            summary << "CGO\t" << it->getName() << "\n";
        }
        
        std::cout << "\nRunning in Event Generation mode..." /*\nWARNING: The output should not be used for any statistical analysis. \n         Neither randomness or completness of the sample is gauranteed!!\n"*/ << std::endl;
    } else if(nIteration > 0 && outputTerm == 0) {
        std::cout.precision(16);
        std::cout << "\nRunning in Event Generation mode... \nWARNING: Output being sent to terminal, no data written to disk!!" /* \nWARNING: The output should not be used for any statistical analysis. \n         Neither randomness or completness of the sample is gauranteed!!\n "*/ << std::endl;
    } else {
        std::cout.precision(16);
        std::cout << std::endl << "Running in Single Event mode...\nNo data will be written to disk!\n" << std::endl;
    }
}

defineParameterDistributions()

void GenerateEvent::defineParameterDistributions ( )

private

The parameter distributions as specified in SomeModel.conf is defined here.

The parameters in the SomeModel.conf either have a flat error or a Gaussian error and might even have both. This member defines the distributions of the parameters using the TF1 class in ROOT.

Definition at line 391 of file GenerateEvent.cpp.

                                                 {
    if (outputTerm == 0 && rank == 0) std::cout << "\nParameters varied in Event Generation:" << std::endl;
    for (std::vector<ModelParameter>::const_iterator it = ModParsVar.begin(); it < ModParsVar.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) {
                        if (outputTerm == 0 && rank == 0) std::cout << CGP[i].getPar(lindex - 1).getname() << ", ";
                    } 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 if (outputTerm == 0 && rank == 0) std::cout << it->getname() << ", "; //<< k << std::endl;
        if (it->geterrf() == 0. && it->geterrg() != 0.) {
            DDist[it->getname()] = new TF1(it->getname().c_str(),
                    "1./sqrt(2.*TMath::Pi())/[1] * exp(-(x-[0])*(x-[0])/2./[1]/[1])",
                    it->getmin(), it->getmax());
            DDist[it->getname()]->SetParameter(0, it->getave());
            DDist[it->getname()]->SetParameter(1, it->geterrg());
        } else if (it->geterrg() == 0. && it->geterrf() != 0.) {
            DDist[it->getname()] = new TF1(it->getname().c_str(),
                    "1/([1]-[0])",
                    it->getmin(), it->getmax());
            DDist[it->getname()]->SetParameter(0, it->getmin());
            DDist[it->getname()]->SetParameter(1, it->getmax());
        } else {
            DDist[it->getname()] = new TF1(it->getname().c_str(),
                    "(TMath::Erf((x-[0]+[2])/sqrt(2.)/[1])-TMath::Erf((x-[0]-[2])/sqrt(2.)/[1]))/4./[2]",
                    it->getmin(), it->getmax());
            DDist[it->getname()]->SetParameter(0, it->getave());
            DDist[it->getname()]->SetParameter(1, it->geterrg());
            DDist[it->getname()]->SetParameter(2, it->geterrf());
        }
    }
    if (outputTerm == 0 && rank == 0) std::cout << std::endl;
}

generate()

void GenerateEvent::generate	(	int unsigned	nIteration_i,
		int	seed = 0,
		bool	weight_i = false
	)

The method used to generate events and format output.

This member creates all out directories that might be needed in case the output is stored on disk. Output on disk is generated as follows:

• Existence of GenerateEvents folder is checked or else created in the current directory.
• The user specified OutDirName_i and a directory called OLD is created under GenerateEvents if it does not already exist.
• If OutDirName_i exists, it is moved into OLD.
• If OutDirName_i exits in OLD is deleted before the existing GenerateEvents/OutDirName_i is moved into OLD.
• In the now empty GenerateEvents/OutDirName_i the directories Parameters and Observables are created. The names indicate what they will contain.
  The file Summary.txt contains the list of parameters that are varied and observables that are generated in a run. This is in the GenerateEvents/OutDirName_i directory.
  

  Parameters

  [in]	rank	the rank of the process for MPI implementations (0 for serial implementation)
  [in]	nIteration	number of events generated
  [in]	seed	seed for the random number generator (default = 0)

Examples

EventGeneration.cpp.

Definition at line 52 of file GenerateEvent.cpp.

{
    weight = weight_i;
    nIteration = nIteration_i;
    if (nIteration == 0) outputTerm = 0;
    int it_comp = 0;
    int rem_iteration = nIteration + 1;
    int itno = 0;
#ifdef _MPI
    gRandom->SetSeed(seed * (/*(unsigned)time(NULL)*/ seed + rank * procnum + nameLen));
#else
    gRandom->SetSeed(seed);
#endif
 
    try {
        /* initialize model and set model parameters */
        initModel();
        
        /* define parameter distributions */
        defineParameterDistributions();
        
        /* create directory structure and necessary files */
        if (rank == 0) createDirectories();
        
        /* memory allocation for MPI */
        sendbuff = new double[buffersize];
        sendbuff_w = new double[buffersize];
        sendbuff_int = new int[1];
        if( rank == 0 ){
            buff = new double*[procnum];
            buff[0]=new double[procnum * buffersize];
            for(int i = 1; i < procnum; i++) buff[i] = buff[i - 1] + buffersize;
            
            buff_w = new double*[procnum];
            buff_w[0]=new double[procnum * buffersize];
            for(int i = 1; i < procnum; i++) buff_w[i] = buff_w[i - 1] + buffersize;
        } else {
            buff = new double*[1];
            buff[0] = new double[1];
            buff_w = new double*[1];
            buff_w[0] = new double[1];
        }
        buff_int = new int*[procnum];
        buff_int[0]=new int[procnum];
        for(int i = 1; i < procnum; i++) buff_int[i] = buff_int[i - 1] + 1;
        
        /* computation of observables */
        while (rem_iteration > 0) {
            itno = rank + nIteration - rem_iteration + 1;
            if (rank < rem_iteration){
                generateRandomEvent(itno);
                for (boost::ptr_vector<Observable>::iterator it = Obs.begin(); it < Obs.end(); it++) {
                    if (it->getObsType().compare("HiggsObservable") != 0) {
                        sendbuff[positionID] = it->computeTheoryValue();
                        if (weight && it->getDistr().compare("noweight") != 0) sendbuff_w[positionID] = it->computeWeight();
                        else sendbuff_w[positionID] = 0.;
                        positionID++;
                    } else {
                        double hw = it->computeWeight();
                        std::vector<double> theoryValues;
                        it->getTheoryValues(theoryValues);
                        for (int j = 0; j < it->getNTheoryValues() + 1 + it->getNChannels(); j++) {
                            sendbuff[positionID] = theoryValues.at(j);
                            if (weight) sendbuff_w[positionID] = hw;
                            positionID++;
                        }
                    }
                }
                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++) {
                        sendbuff[positionID] = it2->computeTheoryValue();
                        if (weight && it2->getDistr().compare("noweight") != 0) sendbuff_w[positionID] = it1->computeWeight();
                        else sendbuff_w[positionID] = 0.;
                        positionID++;
                    }
                }
                sendbuff_int[0] = rank + 1;
            } else {
                for (int i = 0; i < buffersize; i++){
                    sendbuff[i] = 0.;
                    sendbuff_w[i] = 0.;
                }
                sendbuff_int[0] = 0;
            }
            
#ifdef _MPI
                MPI_Gather(sendbuff, buffersize, MPI_DOUBLE, buff[0], buffersize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
                if (weight) MPI_Gather(sendbuff_w, buffersize, MPI_DOUBLE, buff_w[0], buffersize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
                MPI_Allgather(sendbuff_int, 1, MPI_INT, buff_int[0], 1, MPI_INT, MPI_COMM_WORLD);
#else
                buff[0] = sendbuff;
                buff_w[0] = sendbuff_w;
                buff_int[0] = sendbuff_int;
#endif
                
            /* output generation */
            if (rank == 0) {
                itno = nIteration - rem_iteration + 1;
                for (int iproc = 0; iproc < procnum; iproc++) {
                    positionID = 0;
                    if (buff_int[iproc][0] != 0) {
                        for (std::vector<ModelParameter>::iterator it = ModParsVar.begin(); it < ModParsVar.end(); it++) {
                            if (outputTerm == 1) (*ParsOut[it->getname()]) << buff[iproc][positionID] << std::endl;
                            positionID++;
                        }
                        if (outputTerm == 0 && itno != 0) std::cout << "\nEvent No.: " << itno++ << std::endl;
                        else if (outputTerm == 0 && itno++ == 0) std::cout << "\nThe central event is: " << std::endl;
                        if (outputTerm == 0 && Obs.size() > 0) std::cout << "\nObservables: \n" << std::endl;
                        for (boost::ptr_vector<Observable>::iterator it = Obs.begin(); it < Obs.end(); it++) {
                            if (it->getObsType().compare("HiggsObservable") != 0) {
                                if (outputTerm == 0) {
                                    if (weight && it->getDistr().compare("noweight") != 0) std::cout << it->getName() << " = " << buff[iproc][positionID] << " (weight: " << buff_w[iproc][positionID] << ")" << std::endl;
                                    else std::cout << it->getName() << " = " << buff[iproc][positionID] << std::endl;
                                    positionID++;
                                } else {
                                    if (weight && it->getDistr().compare("noweight") != 0) (*ObsOut[it->getName()]) << buff[iproc][positionID] << "\t" << buff_w[iproc][positionID] << std::endl;
                                    else (*ObsOut[it->getName()]) << buff[iproc][positionID] << std::endl;
                                    positionID++;
                                }
                            } else {
                                if (outputTerm == 0) {
                                    if (weight) std::cout << "\n" << it->getName() << " :" << " (weight: " << buff_w[iproc][positionID] << ")" << std::endl;
                                    else std::cout << "\n" << it->getName() << " :" << std::endl;
                                    for (int i = 0; i < it->getNTheoryValues(); i++) {
                                        std::cout << " sigma(" << i + 1 << ") = " << buff[iproc][positionID] << std::endl;
                                        positionID++;
                                    }
                                    std::cout << " BR = " << buff[iproc][positionID] << std::endl;
                                    positionID++;
                                    for (int i = it->getNTheoryValues() + 1; i < it->getNTheoryValues() + 1 + it->getNChannels(); i++) {
                                        std::cout << " mu(" << i - (it->getNTheoryValues() + 1) + 1 << ") = " << buff[iproc][positionID] << std::endl;
                                        positionID++;
                                    }
                                } else {
                                    for (int i = 0; i < it->getNTheoryValues(); i++) {
                                        (*ObsOut[it->getName()]) << std::setw(10) << std::left << buff[iproc][positionID];
                                        positionID++;
                                    }
                                    (*ObsOut[it->getName()]) << std::setw(10) << std::left << buff[iproc][positionID];
                                    positionID++;
                                    for (int i = it->getNTheoryValues() + 1; i < it->getNTheoryValues() + 1 + it->getNChannels(); i++) {
                                        (*ObsOut[it->getName()]) << std::setw(10) << std::left << buff[iproc][positionID];
                                        positionID++;
                                    }
                                    if (weight) (*ObsOut[it->getName()]) << std::setw(10) << std::left << buff_w[iproc][positionID - 1];
                                    (*ObsOut[it->getName()]) << std::endl;
                                }
                            }
                        }
                        if (outputTerm == 0 && CGO.size() > 0) std::cout << "\nCorrelated Gaussian Observables: \n" << std::endl;
                        for (std::vector<CorrelatedGaussianObservables>::iterator it1 = CGO.begin(); it1 < CGO.end(); it1++) {
                            if (outputTerm == 0) {
                                if (weight && !(it1->isPrediction())) std::cout << it1->getName() << ": (weight: " << buff_w[iproc][positionID] << ")" << std::endl;
                                else std::cout << it1->getName() << std::endl;
                            }
                            std::vector<Observable> ObsInCGO = it1->getObs();
                            for (std::vector<Observable>::iterator it2 = ObsInCGO.begin(); it2 < ObsInCGO.end(); it2++) {
                                if (outputTerm == 0) {
                                    if (weight && it2->getDistr().compare("noweight") != 0) std::cout << it2->getName() << " = " << buff[iproc][positionID] << std::endl;
                                    else std::cout << it2->getName() << " = " << buff[iproc][positionID] << std::endl;
                                    positionID++;
                                } else {
                                    if (weight && it2->getDistr().compare("noweight") != 0) (*CGOOut[it1->getName()]) << buff[iproc][positionID] << "\t";
                                    else (*CGOOut[it1->getName()]) << buff[iproc][positionID] << "\t";
                                    positionID++;
                                }
                            }
                            if (outputTerm == 0) std::cout << std::endl;
                            else (*CGOOut[it1->getName()]) << buff_w[iproc][positionID - 1] << std::endl;
                        }
                    }
                }
            }
                
            /* computation of remaining iterations */
            it_comp = 0;
            for(int iproc = 0; iproc < procnum; iproc++){
                it_comp = std::max(it_comp, buff_int[iproc][0]);
            }
            rem_iteration -= it_comp;
        }
        
        /* closing of output streams */
        if (outputTerm == 1 && rank == 0){
            for (std::vector<ModelParameter>::iterator it = ModParsVar.begin(); it < ModParsVar.end(); it++) {
                ParsOut[it->getname()]->close();
            }
            for (boost::ptr_vector<Observable>::iterator it = Obs.begin(); it < Obs.end(); it++){
                ObsOut[it->getName()]->close();
            }
            for (std::vector<CorrelatedGaussianObservables>::iterator it1 = CGO.begin(); it1 < CGO.end(); it1++){
                CGOOut[it1->getName()]->close();
            }
            summary << "Events\t" << nIteration << "\n";
            summary.close();
            std::cout << "Output written to: " << OutDirName << "\n" << std::endl;
        } else {
            if (rank == 0) std::cout << std::endl;
        }
        return;
    } catch (std::string message) {
        std::cerr << message << std::endl;
        exit(EXIT_FAILURE);
    }
    delete buff[0];
    delete [] buff;
    delete [] sendbuff;
    
    delete buff_w[0];
    delete [] buff_w;
    delete [] sendbuff_w;
    
    delete buff_int[0];
    delete [] buff_int;
    delete [] sendbuff_int;
}

GenerateEvent()

GenerateEvent::GenerateEvent	(	ModelFactory &	ModelF,
		ThObsFactory &	ThObsF,
		const std::string &	ModelConf_i,
		const std::string &	OutDirName_i,
		const std::string &	JobTag_i
	)

Constructor.

The default constructor sets the names of the configuration file and the names of the specific output directory along with a job ID if it is specified as an argument to the executable. Possible arguments to the executable are:

• SomeModel.conf –noMC : For single event (central event) printed to terminal only.
• SomeModel.conf –noMC –it=10 : For the central event and 10 events printed to terminal only.
• SomeModel.conf –noMC –it=10 –output_folder FOLDER: For the central event and 10 events printed to GenerateEvents/FOLDER only.

  Parameters

  [in]	ModelConf_i	the name of the input configuration file for the model name, the model parameters and observables to be calculated.
  [in]	OutDirName_i	the name of the root output directory to be given
  [in]	JobTag_i	optional job tag that might be specified
  [in]	noMC_i	the noMC specification given to the executable=

Definition at line 13 of file GenerateEvent.cpp.

: myInputParser(ModelF, ThObsF)
{
    outputTerm = 0;
    ModelConf = ModelConf_i;
    JobTag = JobTag_i;
    if (OutDirName_i != ""){
        OutDirName = "GeneratedEvents/" + OutDirName_i + JobTag;
        OldOutDirName = ("GeneratedEvents/DELETED/" + OutDirName_i + JobTag);
        ObsDirName = OutDirName + "/Observables";
        ParsDirName = OutDirName + "/Parameters";
        CGODirName = OutDirName + "/CGO";
        SMDebugDirName = OutDirName + "/SMDebug";
        SUSYDebugDirName = OutDirName + "/SUSYDebug";
        outputTerm = 1;
    }
    //noMC = noMC_i;
    
#ifdef _MPI
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &procnum);
    MPI_Get_processor_name(processorName, &nameLen);
#else
    rank = 0;
    procnum = 1;
#endif
}

generateRandomEvent()

void GenerateEvent::generateRandomEvent ( int  iterationNo )

private

This member generates random numbers for the parameters being varied in the model. The first set is always the central value of the parameter.

Parameters

[in]

iterationNo

the iteration number

Definition at line 433 of file GenerateEvent.cpp.

                                                       {
    positionID = 0;
 
    std::vector<double> vec(ModParsVar.size(), 0.);
    for (unsigned int i = 0; i < vec.size(); i++) {
        if (iterationNo == 0) vec[i] = ModParsVar[i].getave();
        else vec[i] = DDist[ModParsVar[i].getname()]->GetRandom();
    }
 
    setDParsFromParameters(vec, DPars);
    for (std::vector<ModelParameter>::const_iterator it = ModParsVar.begin(); it < ModParsVar.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) {
                        sendbuff[positionID] = DPars[CGP[i].getPar(lindex - 1).getname()];
                        sendbuff_w[positionID] = DPars[CGP[i].getPar(lindex - 1).getname()];
                        positionID++;
                    } 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 {
            sendbuff[positionID] = DPars[it->getname()];
            sendbuff_w[positionID] = DPars[it->getname()];
            positionID++;
        }
    }
    Mod->Update(DPars);
}

initModel()

void GenerateEvent::initModel ( )

private

Definition at line 329 of file GenerateEvent.cpp.

                              {
    ModelName = myInputParser.ReadParameters(ModelConf, rank, ModPars, Obs, Obs2D, CGO, CGP);
    Mod = myInputParser.getModel();
    if (Obs.size() == 0 && CGO.size() == 0) {
        if (rank == 0) throw std::runtime_error("\nGenerateEvent::initModel(): No observables or correlated Gaussian observables defined in " + ModelConf + " file\n");
        else sleep(2);
    }
    std::map<std::string, double> DP;
    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("GenerateEvents::initModel(): " + 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 (myInputParser.getModel()->getmissingModelParameters().size() > 0) {
            if (rank == 0) std::cout << "\nPlease set the following parameters in the model configuration files:\n" << std::endl;
            for (std::vector<std::string>::iterator it = myInputParser.getModel()->getmissingModelParameters().begin(); it != myInputParser.getModel()->getmissingModelParameters().end(); it++) {
                if (rank == 0) std::cout << "ModelParameter\t" << *it << std::endl;
            }
            std::cout << std::endl;
            myInputParser.getModel()->getmissingModelParameters().clear();
        }
        if (rank == 0) throw std::runtime_error("\nERROR: " + ModelName + " cannot be initialized");
        else sleep(2);
    }
    std::vector<std::string> unknownParameters = Mod->getUnknownParameters();
    for (std::vector<ModelParameter>::iterator it = ModPars.begin(); it < ModPars.end(); it++) {
        if (it->geterrg() > 0. || it->geterrf() > 0.) {
            if (std::find(unknownParameters.begin(), unknownParameters.end(), it->getname()) == unknownParameters.end()) ModParsVar.push_back(*it);
        }
    }
 
    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 << " in model initialization not added the Event Generation." << std::endl;
    }
 
    buffersize = ModParsVar.size();
    for (std::vector<CorrelatedGaussianObservables>::iterator it = CGO.begin(); it < CGO.end(); it++) {
        buffersize += it->getObs().size();
    }
    for (boost::ptr_vector<Observable>::iterator it = Obs.begin(); it < Obs.end(); it++) {
        if (it->getObsType().compare("HiggsObservable") == 0) {
            buffersize += it->getNTheoryValues() + 1 + it->getNChannels();
        } else {
            buffersize += 1;
        }
    }
}

setDParsFromParameters()

void GenerateEvent::setDParsFromParameters ( const std::vector< double > &  parameters, std::map< std::string, double > &  DPars_i  )

private

Definition at line 469 of file GenerateEvent.cpp.

                                                                                                                  {
    std::map<std::string, std::vector<double> > cgpmap;
 
    unsigned int k = 0;
    for (std::vector<ModelParameter>::const_iterator it = ModParsVar.begin(); it < ModParsVar.end(); it++) {
 
        if (it->IsCorrelated()) {
            std::string index = it->getname().substr(it->getCgp_name().size());
            unsigned long int lindex = strtol(index.c_str(), NULL, 10);
            if (lindex - 1 == cgpmap[it->getCgp_name()].size()) cgpmap[it->getCgp_name()].push_back(parameters[k]);
            else {
                std::stringstream out;
                out << it->getname() << " " << lindex;
                throw std::runtime_error("GenerateEvent::setDParsFromParameters(): " + out.str() + "seems to be a CorrelatedGaussianParameters object but the corresponding parameters are missing or not in the right order");
            }
 
        } else DPars_i[it->getname()] = parameters[k];
        k++;
    }
 
    for (unsigned int j = 0; j < CGP.size(); j++) {
        std::vector<double> current = cgpmap.at(CGP[j].getName());
        if (current.size() != CGP[j].getPars().size()) {
            std::stringstream out;
            out << CGP[j].getName();
            throw std::runtime_error("GenerateEvent::setDParsFromParameters(): " + out.str() + " appears to be represented in cgpmap with a wrong size");
        }
 
        std::vector<double> porig = CGP[j].getOrigParsValue(current);
 
        for (unsigned int l = 0; l < porig.size(); l++) {
            DPars_i[CGP[j].getPar(l).getname()] = porig[l];
        }
    }
}

~GenerateEvent()

GenerateEvent::~GenerateEvent ( )

virtual

The default destructor.

Definition at line 45 of file GenerateEvent.cpp.

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

Variable Documentation

buff

double** GenerateEvent::buff

private

Definition at line 150 of file GenerateEvent.h.

buff_int

int** GenerateEvent::buff_int

private

Definition at line 153 of file GenerateEvent.h.

buff_w

double** GenerateEvent::buff_w

private

Definition at line 151 of file GenerateEvent.h.

buffersize

int GenerateEvent::buffersize

private

Definition at line 147 of file GenerateEvent.h.

CGO

std::vector<CorrelatedGaussianObservables> GenerateEvent::CGO

private

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

Definition at line 125 of file GenerateEvent.h.

CGODirName

std::string GenerateEvent::CGODirName

private

String for the name of the Correlated Gaussian Observables output directory.

Definition at line 131 of file GenerateEvent.h.

CGOOut

std::map<std::string, boost::shared_ptr<std::ofstream> > GenerateEvent::CGOOut

private

Map of output stream for corellated Gaussian observables.

Definition at line 118 of file GenerateEvent.h.

CGP

std::vector<CorrelatedGaussianParameters> GenerateEvent::CGP

private

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

Definition at line 126 of file GenerateEvent.h.

DDist

std::map<std::string, TF1*> GenerateEvent::DDist

private

Map of parameter distributions.

Definition at line 116 of file GenerateEvent.h.

DPars

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

private

Map of parameters to be passed to Model().

Definition at line 115 of file GenerateEvent.h.

JobTag

std::string GenerateEvent::JobTag

private

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

Definition at line 135 of file GenerateEvent.h.

Mod

StandardModel* GenerateEvent::Mod

private

Name of the model as defined in SomeModel.conf.

Definition at line 120 of file GenerateEvent.h.

ModelConf

std::string GenerateEvent::ModelConf

private

String for the name of the SomeModel.conf file.

Definition at line 127 of file GenerateEvent.h.

ModelName

std::string GenerateEvent::ModelName

private

Definition at line 154 of file GenerateEvent.h.

ModPars

std::vector<ModelParameter> GenerateEvent::ModPars

private

Vector for the model parameters defined in SomeModel.conf.

Definition at line 121 of file GenerateEvent.h.

ModParsVar

std::vector<ModelParameter> GenerateEvent::ModParsVar

private

Vector for the model parameters varied in SomeModel.conf.

Definition at line 122 of file GenerateEvent.h.

myInputParser

InputParser GenerateEvent::myInputParser

private

An oject of the InputParser() class.

Definition at line 114 of file GenerateEvent.h.

nameLen

int GenerateEvent::nameLen

private

Definition at line 141 of file GenerateEvent.h.

nIteration

int GenerateEvent::nIteration

private

Definition at line 145 of file GenerateEvent.h.

Obs

boost::ptr_vector<Observable> GenerateEvent::Obs

private

Vector for the observables defined in SomeModel.conf.

Definition at line 123 of file GenerateEvent.h.

Obs2D

std::vector<Observable2D> GenerateEvent::Obs2D

private

Vector for the Observables2D defined in SomeModel.conf.

Definition at line 124 of file GenerateEvent.h.

ObsDirName

std::string GenerateEvent::ObsDirName

private

String for the name of the observables output directory.

Definition at line 130 of file GenerateEvent.h.

ObsOut

std::map<std::string, boost::shared_ptr<std::ofstream> > GenerateEvent::ObsOut

private

Map of output stream for observables.

Definition at line 117 of file GenerateEvent.h.

OldOutDirName

std::string GenerateEvent::OldOutDirName

private

String for the name of the backup output directory.

Definition at line 129 of file GenerateEvent.h.

OutDirName

std::string GenerateEvent::OutDirName

private

String for the name of the output directory.

Definition at line 128 of file GenerateEvent.h.

outputTerm

bool GenerateEvent::outputTerm

private

Flag to specify output stream storage.

Definition at line 137 of file GenerateEvent.h.

ParsDirName

std::string GenerateEvent::ParsDirName

private

String for the name of the parameters output directory.

Definition at line 134 of file GenerateEvent.h.

ParsOut

std::map<std::string, boost::shared_ptr<std::ofstream> > GenerateEvent::ParsOut

private

Map of output stream for parameters.

Definition at line 119 of file GenerateEvent.h.

positionID

int GenerateEvent::positionID

private

Definition at line 146 of file GenerateEvent.h.

processorName

char GenerateEvent::processorName[MPI_MAX_PROCESSOR_NAME]

private

Definition at line 142 of file GenerateEvent.h.

procnum

int GenerateEvent::procnum

private

Definition at line 139 of file GenerateEvent.h.

rank

int GenerateEvent::rank

private

Definition at line 138 of file GenerateEvent.h.

sendbuff

double* GenerateEvent::sendbuff

private

Definition at line 148 of file GenerateEvent.h.

sendbuff_int

int* GenerateEvent::sendbuff_int

private

Definition at line 152 of file GenerateEvent.h.

sendbuff_w

double* GenerateEvent::sendbuff_w

private

Definition at line 149 of file GenerateEvent.h.

SMDebugDirName

std::string GenerateEvent::SMDebugDirName

private

String for the name of the observables output directory.

Definition at line 132 of file GenerateEvent.h.

summary

std::ofstream GenerateEvent::summary

private

Definition at line 144 of file GenerateEvent.h.

SUSYDebugDirName

std::string GenerateEvent::SUSYDebugDirName

private

String for the name of the Correlated Gaussian Observables output directory.

Definition at line 133 of file GenerateEvent.h.

weight

bool GenerateEvent::weight

private

Definition at line 155 of file GenerateEvent.h.