int main( int argc, char **argv ) {
if( argc < 3 ) {
cout << "Usage: " << argv[0] << " <config_file> <events_count> " << endl;
return -1;
}
int events_limit = atoi( argv[2] );
//
// Initialize pythia
//
Pythia8::Pythia pythia;
Pythia8::Event& event = pythia.event;
Pythia8ToHepMC toHepMC;
// Use this line to output all available options and their default values
//pythia.settings.listAll(); exit(0);
pythia.readFile(argv[1]);
pythia.init();
//
// Initialize AcerDET
//
const std::string configFileName = "acerdet.dat";
Configuration configuration = Configuration::fromFile( configFileName );
IParticleDataProviderFactory *pdpFactory =
new external::Pythia8_ParticleDataProviderFactory();
IHistogramManager *histoManager =
new external::Root_HistogramManager();
external::Root_NTupleManager nTuple;
AcerDET acerDet(
configuration,
pdpFactory,
histoManager
);
nTuple.init();
acerDet.printInfo();
OutputRecord oRec;
for( int iEvent = 0; iEvent < events_limit; ++iEvent ) {
// printf("Event %d\n", iEvent);
if( !pythia.next() ) {
printf("continue ...\n");
continue;
}
resetRecord(oRec);
GenEvent *hepmc = new GenEvent();
toHepMC.fill_next_event( event, hepmc );
// printf (" ---- PRINTING --- \n");
// hepmc->print();
const Real64_t weigth = 1.0;
const Int32_t processId = 1;
InputRecord iRec = external::HepMC_InputConverter::convert( *hepmc );
// wypisz iRec
if (iEvent == 0) {
cout << iRec;
}
acerDet.analyseRecord(iRec, oRec, weigth);
nTuple.fill(iRec, oRec, weigth, processId);
delete hepmc;
}
acerDet.printResults();
char inputname[1000] = "";
sprintf( inputname, argv[1] );
char outputname[1000] = "";
strcat( outputname, inputname );
strcat( outputname, ".root" );
TFile scanMiniTreeFile( outputname, "recreate" );
scanMiniTreeFile.cd();
acerDet.storeHistograms();
nTuple.write();
delete pdpFactory;
delete histoManager;
return 0;
}
int main(int argc, char *argv[])
{
char appName[] = "DelphesPythia8";
stringstream message;
TFile *outputFile = 0;
TStopwatch readStopWatch, procStopWatch;
ExRootTreeWriter *treeWriter = 0;
ExRootTreeBranch *branchEvent = 0;
ExRootConfReader *confReader = 0;
Delphes *modularDelphes = 0;
DelphesFactory *factory = 0;
TObjArray *stableParticleOutputArray = 0, *allParticleOutputArray = 0, *partonOutputArray = 0;
Long64_t eventCounter, errorCounter;
Long64_t numberOfEvents, timesAllowErrors;
Pythia8::Pythia *pythia = 0;
if(argc != 4)
{
cout << " Usage: " << appName << " config_file" << " pythia_card" << " output_file" << endl;
cout << " config_file - configuration file in Tcl format," << endl;
cout << " pythia_card - Pythia8 configuration file," << endl;
cout << " output_file - output file in ROOT format." << endl;
return 1;
}
signal(SIGINT, SignalHandler);
gROOT->SetBatch();
int appargc = 1;
char *appargv[] = {appName};
TApplication app(appName, &appargc, appargv);
try
{
outputFile = TFile::Open(argv[3], "CREATE");
if(outputFile == NULL)
{
message << "can't create output file " << argv[3];
throw runtime_error(message.str());
}
treeWriter = new ExRootTreeWriter(outputFile, "Delphes");
branchEvent = treeWriter->NewBranch("Event", HepMCEvent::Class());
confReader = new ExRootConfReader;
confReader->ReadFile(argv[1]);
modularDelphes = new Delphes("Delphes");
modularDelphes->SetConfReader(confReader);
modularDelphes->SetTreeWriter(treeWriter);
factory = modularDelphes->GetFactory();
allParticleOutputArray = modularDelphes->ExportArray("allParticles");
stableParticleOutputArray = modularDelphes->ExportArray("stableParticles");
partonOutputArray = modularDelphes->ExportArray("partons");
modularDelphes->InitTask();
// Initialize pythia
pythia = new Pythia8::Pythia;
if(pythia == NULL)
{
throw runtime_error("can't create Pythia instance");
}
// Read in commands from configuration file
pythia->readFile(argv[2]);
// Extract settings to be used in the main program
numberOfEvents = pythia->mode("Main:numberOfEvents");
timesAllowErrors = pythia->mode("Main:timesAllowErrors");
pythia->init();
// ExRootProgressBar progressBar(numberOfEvents - 1);
ExRootProgressBar progressBar(-1);
// Loop over all events
errorCounter = 0;
treeWriter->Clear();
modularDelphes->Clear();
readStopWatch.Start();
for(eventCounter = 0; eventCounter < numberOfEvents && !interrupted; ++eventCounter)
{
if(!pythia->next())
{
// If failure because reached end of file then exit event loop
if (pythia->info.atEndOfFile())
{
cerr << "Aborted since reached end of Les Houches Event File" << endl;
break;
}
// First few failures write off as "acceptable" errors, then quit
if (++errorCounter < timesAllowErrors) continue;
cerr << "Event generation aborted prematurely, owing to error!" << endl;
break;
}
readStopWatch.Stop();
procStopWatch.Start();
ConvertInput(eventCounter, pythia, branchEvent, factory,
allParticleOutputArray, stableParticleOutputArray, partonOutputArray,
&readStopWatch, &procStopWatch);
modularDelphes->ProcessTask();
procStopWatch.Stop();
treeWriter->Fill();
treeWriter->Clear();
modularDelphes->Clear();
readStopWatch.Start();
progressBar.Update(eventCounter, eventCounter);
}
progressBar.Update(eventCounter, eventCounter, kTRUE);
progressBar.Finish();
pythia->statistics();
modularDelphes->FinishTask();
treeWriter->Write();
cout << "** Exiting..." << endl;
delete pythia;
delete modularDelphes;
delete confReader;
delete treeWriter;
delete outputFile;
return 0;
}
catch(runtime_error &e)
{
if(treeWriter) delete treeWriter;
if(outputFile) delete outputFile;
cerr << "** ERROR: " << e.what() << endl;
return 1;
}
}
int main(int argc, char * argv[]){
// declaring and initializing some variables. Most of them will be set according to command line options passed to the program after parsing of command line arguments. However, if Boost is not used, the only available command line option is the number of events to generate; other variables will use the values set below
std::size_t nevents = 0; // number of events to generate
std::string pythia_cfgfile = "Z2uubar.cmnd"; // name of PYTHIA cofiguration file
std::string output_filename = "Z2uubar.root"; // name of the output file
bool verbose = false; // increased verbosity switch
#ifdef USE_BOOST
try {
boost::program_options::options_description desc("Usage");
// defining command line options. See boost::program_options documentation for more details
desc.add_options()
("help", "produce this help message")
("nevents,n", boost::program_options::value<std::size_t>(&nevents), "number of events to generate")
("pythiacfg,P", boost::program_options::value<std::string>(&pythia_cfgfile)->default_value("Z2uubar.cmnd"), "PYTHIA config file")
("outfile,o", boost::program_options::value<std::string>(&output_filename)->default_value("Z2uubar.root"), "Output file")
("verbose,v", boost::program_options::bool_switch()->default_value(false), "Run with increased verbosity")
;
boost::program_options::variables_map vm;
boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
boost::program_options::notify(vm);
if(vm.find("help") != vm.end() || argc < 2) {
std::cout << "Generator of inclusive events. Version " << Generator_VERSION_MAJOR << '.' << Generator_VERSION_MINOR << std::endl;
std::cout << desc << std::endl;
return EXIT_SUCCESS;
}
verbose = vm.at("verbose").as<bool>();
} catch(std::exception const & e) {
std::cout << e.what() << std::endl;
return EXIT_FAILURE;
}
#else
if(argc < 2) {
std::cout << "Generator of inclusive events. Version " << Generator_VERSION_MAJOR << '.' << Generator_VERSION_MINOR << std::endl;
std::cout << "Usage: " << argv[0] << " n, where \"n\" is a number of events to generate" << std::endl;
std::cout << "WARNING! This version of the generator does not use program options parser, which means that you are personally responsible for providing correct options to this program." << std::endl;
return EXIT_SUCCESS;
} else {
nevents = std::stoull(argv[1]);
}
#endif
auto start_time = std::chrono::system_clock::now();
auto last_timestamp = start_time;
if(verbose) {
std::cout << "PYTHIA config file: \"" << pythia_cfgfile << "\"" << std::endl << nevents << " events will be generated." << std:: endl;
}
if(verbose) {
std::cout << "Prepairing data store" << std::endl;
}
// prepairing event store
podio::EventStore store;
podio::ROOTWriter writer(output_filename, &store);
// registering collections
auto & evinfocoll = store.create<fcc::EventInfoCollection>("EventInfo");
auto & pcoll = store.create<fcc::MCParticleCollection>("GenParticle");
auto & vcoll = store.create<fcc::GenVertexCollection>("GenVertex");
writer.registerForWrite<fcc::EventInfoCollection>("EventInfo");
writer.registerForWrite<fcc::MCParticleCollection>("GenParticle");
writer.registerForWrite<fcc::GenVertexCollection>("GenVertex");
if(verbose) {
std::cout << "Initializing PYTHIA" << std::endl;
}
// initializing PYTHIA
Pythia8::Pythia pythia; // creating PYTHIA generator object
pythia.readFile(pythia_cfgfile); // reading settings from file
pythia.init(); // initializing PYTHIA generator
// Interface for conversion from Pythia8::Event to HepMC event.
HepMC::Pythia8ToHepMC ToHepMC;
std::size_t counter = 0; // number of "interesting" (that satisfy all the requirements) events generated so far
std::size_t total = 0; // total number of events generated so far
if(verbose) {
std::cout << "Starting to generate events" << std::endl;
}
std::map<std::size_t, std::size_t> stable_ptcs_count;
while(counter < nevents) {
if(pythia.next()) {
++total;
// creating HepMC event storage
HepMC::GenEvent * hepmcevt = new HepMC::GenEvent(HepMC::Units::GEV, HepMC::Units::MM);
// converting generated event to HepMC format
ToHepMC.fill_next_event(pythia, hepmcevt);
auto nstable = std::count_if(hepmcevt->particles_begin(), hepmcevt->particles_end(), [](HepMC::GenParticle const * const ptc_ptr) {return ptc_ptr->status() == 1;});
if(nstable <= 7) {
stable_ptcs_count[nstable]++;
++counter;
if(verbose && counter % 100 == 0) {
std::cout << counter << " events with with 7 or less particles in the final state have been generated (" << total << " total). " << std::chrono::duration<double>(std::chrono::system_clock::now() - last_timestamp).count() / 100 << "events / sec" << std::endl;
last_timestamp = std::chrono::system_clock::now();
}
// filling event info
auto evinfo = fcc::EventInfo();
evinfo.Number(counter); // Number takes int as its parameter, so here's a narrowing conversion (std::size_t to int). Should be safe unless we get 2^32 events or more. Then undefined behaviour
evinfocoll.push_back(evinfo);
// filling vertices
std::unordered_map<HepMC::GenVertex *, fcc::GenVertex> vtx_map;
for(auto iv = hepmcevt->vertices_begin(), endv = hepmcevt->vertices_end(); iv != endv; ++iv) {
auto vtx = fcc::GenVertex();
vtx.Position().X = (*iv)->position().x();
vtx.Position().Y = (*iv)->position().y();
vtx.Position().Z = (*iv)->position().z();
vtx.Ctau((*iv)->position().t());
vtx_map.emplace(*iv, vtx);
vcoll.push_back(vtx);
}
// filling particles
for(auto ip = hepmcevt->particles_begin(), endp = hepmcevt->particles_end(); ip != endp; ++ip) {
auto ptc = fcc::MCParticle();
auto & core = ptc.Core();
core.Type = (*ip)->pdg_id();
core.Status = (*ip)->status();
core.Charge = pythia.particleData.charge(core.Type); // PYTHIA returns charge as a double value (in case it's quark), so here's a narrowing conversion (double to int), but here it's safe
core.P4.Mass = (*ip)->momentum().m();
core.P4.Px = (*ip)->momentum().px();
core.P4.Py = (*ip)->momentum().py();
core.P4.Pz = (*ip)->momentum().pz();
auto prodvtx = vtx_map.find((*ip)->production_vertex());
if(prodvtx != vtx_map.end()) {
ptc.StartVertex(prodvtx->second);
}
auto endvtx = vtx_map.find((*ip)->end_vertex());
if(endvtx != vtx_map.end()) {
ptc.EndVertex(endvtx->second);
}
pcoll.push_back(ptc);
}
writer.writeEvent();
store.clearCollections();
}
// freeing resources
if(hepmcevt) {
delete hepmcevt;
hepmcevt = nullptr;
}
}
}
writer.finish();
std::cout << counter << " events with 7 or less particles in the final state have been generated (" << total << " total)." << std::endl;
for(auto const & nv : stable_ptcs_count) {
std::cout << std::setw(4) << std::right << nv.first << std::setw(4) << std::right << nv.second << "(" << static_cast<long double>(nv.second) * static_cast<long double>(100) / static_cast<long double>(total) << "%)" << std::endl;
}
auto elapsed_seconds = std::chrono::duration<double>(std::chrono::system_clock::now() - start_time).count();
std::cout << "Elapsed time: " << elapsed_seconds << " s (" << static_cast<long double>(counter) / static_cast<long double>(elapsed_seconds) << " events / s)" << std::endl;
return EXIT_SUCCESS;
}