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;
}
}
Bool_t LHCOConverter::ReadLine(FILE *inputFile)
{
int rc;
if(!fgets(fBuffer, kBufferSize, inputFile)) return kFALSE;
DelphesStream bufferStream(fBuffer);
rc = bufferStream.ReadInt(fIntParam[0]);
if(!rc)
{
return kTRUE;
}
if(fIntParam[0] == 0)
{
rc = bufferStream.ReadInt(fEventNumber)
&& bufferStream.ReadInt(fTriggerWord);
if(!rc)
{
cerr << "** ERROR: " << "invalid event format" << endl;
return kFALSE;
}
if(fIsReadyToFill && fTreeWriter)
{
fTreeWriter->Fill();
fTreeWriter->Clear();
}
AnalyseEvent(fBranchEvent);
fIsReadyToFill = kTRUE;
}
else
{
rc = bufferStream.ReadInt(fIntParam[1])
&& bufferStream.ReadDbl(fDblParam[0])
&& bufferStream.ReadDbl(fDblParam[1])
&& bufferStream.ReadDbl(fDblParam[2])
&& bufferStream.ReadDbl(fDblParam[3])
&& bufferStream.ReadDbl(fDblParam[4])
&& bufferStream.ReadDbl(fDblParam[5])
&& bufferStream.ReadDbl(fDblParam[6]);
if(!rc)
{
cerr << "** ERROR: " << "invalid object format" << endl;
return kFALSE;
}
switch(fIntParam[1])
{
case 0: AnalysePhoton(fBranchPhoton); break;
case 1: AnalyseElectron(fBranchElectron); break;
case 2: AnalyseMuon(fBranchMuon); break;
case 3: AnalyseTau(fBranchJet); break;
case 4: AnalyseJet(fBranchJet); break;
case 6: AnalyseMissingET(fBranchMissingET); break;
}
}
return kTRUE;
}
int main(int argc, char *argv[])
{
char appName[] = "DelphesLHEF";
stringstream message;
FILE *inputFile = 0;
TFile *outputFile = 0;
TStopwatch readStopWatch, procStopWatch;
ExRootTreeWriter *treeWriter = 0;
ExRootTreeBranch *branchEvent = 0, *branchWeight = 0;
ExRootConfReader *confReader = 0;
Delphes *modularDelphes = 0;
DelphesFactory *factory = 0;
TObjArray *stableParticleOutputArray = 0, *allParticleOutputArray = 0, *partonOutputArray = 0;
DelphesLHEFReader *reader = 0;
Int_t i, maxEvents, skipEvents;
Long64_t length, eventCounter;
if(argc < 3)
{
cout << " Usage: " << appName << " config_file" << " output_file" << " [input_file(s)]" << endl;
cout << " config_file - configuration file in Tcl format," << endl;
cout << " output_file - output file in ROOT format," << endl;
cout << " input_file(s) - input file(s) in LHEF format," << endl;
cout << " with no input_file, or when input_file is -, read standard input." << endl;
return 1;
}
signal(SIGINT, SignalHandler);
gROOT->SetBatch();
int appargc = 1;
char *appargv[] = {appName};
TApplication app(appName, &appargc, appargv);
try
{
outputFile = TFile::Open(argv[2], "CREATE");
if(outputFile == NULL)
{
message << "can't create output file " << argv[2];
throw runtime_error(message.str());
}
treeWriter = new ExRootTreeWriter(outputFile, "Delphes");
branchEvent = treeWriter->NewBranch("Event", LHEFEvent::Class());
branchWeight = treeWriter->NewBranch("Weight", Weight::Class());
confReader = new ExRootConfReader;
confReader->ReadFile(argv[1]);
maxEvents = confReader->GetInt("::MaxEvents", 0);
skipEvents = confReader->GetInt("::SkipEvents", 0);
if(maxEvents < 0)
{
throw runtime_error("MaxEvents must be zero or positive");
}
if(skipEvents < 0)
{
throw runtime_error("SkipEvents must be zero or positive");
}
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");
reader = new DelphesLHEFReader;
modularDelphes->InitTask();
i = 3;
do
{
if(interrupted) break;
if(i == argc || strncmp(argv[i], "-", 2) == 0)
{
cout << "** Reading standard input" << endl;
inputFile = stdin;
length = -1;
}
else
{
cout << "** Reading " << argv[i] << endl;
inputFile = fopen(argv[i], "r");
if(inputFile == NULL)
{
message << "can't open " << argv[i];
throw runtime_error(message.str());
}
fseek(inputFile, 0L, SEEK_END);
length = ftello(inputFile);
fseek(inputFile, 0L, SEEK_SET);
if(length <= 0)
{
fclose(inputFile);
++i;
continue;
}
}
reader->SetInputFile(inputFile);
ExRootProgressBar progressBar(length);
// Loop over all objects
eventCounter = 0;
treeWriter->Clear();
modularDelphes->Clear();
reader->Clear();
readStopWatch.Start();
while((maxEvents <= 0 || eventCounter - skipEvents < maxEvents) &&
reader->ReadBlock(factory, allParticleOutputArray,
stableParticleOutputArray, partonOutputArray) && !interrupted)
{
if(reader->EventReady())
{
++eventCounter;
readStopWatch.Stop();
if(eventCounter > skipEvents)
{
readStopWatch.Stop();
procStopWatch.Start();
modularDelphes->ProcessTask();
procStopWatch.Stop();
reader->AnalyzeEvent(branchEvent, eventCounter, &readStopWatch, &procStopWatch);
reader->AnalyzeWeight(branchWeight);
treeWriter->Fill();
treeWriter->Clear();
}
modularDelphes->Clear();
reader->Clear();
readStopWatch.Start();
}
progressBar.Update(ftello(inputFile), eventCounter);
}
fseek(inputFile, 0L, SEEK_END);
progressBar.Update(ftello(inputFile), eventCounter, kTRUE);
progressBar.Finish();
if(inputFile != stdin) fclose(inputFile);
++i;
}
while(i < argc);
modularDelphes->FinishTask();
treeWriter->Write();
cout << "** Exiting..." << endl;
delete reader;
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[])
{
char appName[] = "DelphesCMSFWLite";
stringstream message;
TFile *inputFile = 0;
TFile *outputFile = 0;
TStopwatch eventStopWatch;
ExRootTreeWriter *treeWriter = 0;
ExRootTreeBranch *branchEvent = 0, *branchRwgt = 0;
ExRootConfReader *confReader = 0;
Delphes *modularDelphes = 0;
DelphesFactory *factory = 0;
TObjArray *allParticleOutputArray = 0, *stableParticleOutputArray = 0, *partonOutputArray = 0;
Int_t i;
Long64_t eventCounter, numberOfEvents;
if(argc < 4)
{
cout << " Usage: " << appName << " config_file" << " output_file" << " input_file(s)" << endl;
cout << " config_file - configuration file in Tcl format," << endl;
cout << " output_file - output file in ROOT format," << endl;
cout << " input_file(s) - input file(s) in ROOT format." << endl;
return 1;
}
signal(SIGINT, SignalHandler);
gROOT->SetBatch();
int appargc = 1;
char *appargv[] = {appName};
TApplication app(appName, &appargc, appargv);
FWLiteEnabler::enable();
try
{
outputFile = TFile::Open(argv[2], "CREATE");
if(outputFile == NULL)
{
message << "can't open " << argv[2] << endl;
throw runtime_error(message.str());
}
treeWriter = new ExRootTreeWriter(outputFile, "Delphes");
branchEvent = treeWriter->NewBranch("Event", HepMCEvent::Class());
branchRwgt = treeWriter->NewBranch("Rwgt", Weight::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();
for(i = 3; i < argc && !interrupted; ++i)
{
cout << "** Reading " << argv[i] << endl;
inputFile = TFile::Open(argv[i]);
if(inputFile == NULL)
{
message << "can't open " << argv[i] << endl;
throw runtime_error(message.str());
}
fwlite::Event event(inputFile);
numberOfEvents = event.size();
if(numberOfEvents <= 0) continue;
// ExRootProgressBar progressBar(numberOfEvents - 1);
ExRootProgressBar progressBar(-1);
// Loop over all objects
eventCounter = 0;
modularDelphes->Clear();
treeWriter->Clear();
for(event.toBegin(); !event.atEnd() && !interrupted; ++event)
{
ConvertInput(event, eventCounter, branchEvent, branchRwgt, factory,
allParticleOutputArray, stableParticleOutputArray, partonOutputArray);
modularDelphes->ProcessTask();
treeWriter->Fill();
modularDelphes->Clear();
treeWriter->Clear();
progressBar.Update(eventCounter, eventCounter);
++eventCounter;
}
progressBar.Update(eventCounter, eventCounter, kTRUE);
progressBar.Finish();
inputFile->Close();
}
modularDelphes->FinishTask();
treeWriter->Write();
cout << "** Exiting..." << endl;
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[])
{
char appName[] = "ExRootLHEFConverter";
if(argc != 3)
{
cout << " Usage: " << appName << " input_file" << " output_file" << endl;
cout << " input_file - input file in LHEF format," << endl;
cout << " output_file - output file in ROOT format." << endl;
return 1;
}
gROOT->SetBatch();
int appargc = 1;
char *appargv[] = {appName};
TApplication app(appName, &appargc, appargv);
// Open a stream connected to an event file:
ifstream inputFileStream(argv[1]);
// Create the Reader object:
LHEF::Reader *inputReader = new LHEF::Reader(inputFileStream);
TFile *outputFile = TFile::Open(argv[2], "RECREATE");
ExRootTreeWriter *treeWriter = new ExRootTreeWriter(outputFile, "LHEF");
// generated event from LHEF
ExRootTreeBranch *branchEvent = treeWriter->NewBranch("Event", TRootLHEFEvent::Class());
// generated partons from LHEF
ExRootTreeBranch *branchParticle = treeWriter->NewBranch("Particle", TRootLHEFParticle::Class());
cout << "** Calculating number of events to process. Please wait..." << endl;
Long64_t allEntries = inputReader->getNumberOfEvents();
cout << "** Input file contains " << allEntries << " events" << endl;
if(allEntries > 0)
{
ExRootProgressBar progressBar(allEntries);
// Loop over all events
Long64_t entry = 0;
while(inputReader->readEvent())
{
treeWriter->Clear();
AnalyseEvent(inputReader, branchEvent, entry + 1);
AnalyseParticles(inputReader, branchParticle);
treeWriter->Fill();
progressBar.Update(entry);
++entry;
}
progressBar.Finish();
}
treeWriter->Write();
cout << "** Exiting..." << endl;
delete treeWriter;
delete outputFile;
delete inputReader;
}