int main(int argc, char *argv[])
{
// Declaration of variables
ExRootConfReader *confReader = 0;
Delphes *modularDelphes = 0;
DelphesFactory *factory = 0;
TObjArray *allParticleOutputArray = 0;
TObjArray *stableParticleOutputArray = 0;
TObjArray *partonOutputArray = 0;
Int_t event;
TObjArray *inputArray = 0;
TIterator *inputIterator = 0;
Candidate *candidate = 0;
TLorentzVector momentum;
JetDefinition *definition = 0;
vector<PseudoJet> inputList, outputList;
PseudoJet jet;
gROOT->SetBatch();
int appargc = 1;
char appName[] = "ExternalFastJetBasic";
char *appargv[] = {appName};
TApplication app(appName, &appargc, appargv);
if(argc != 2)
{
cout << " Usage: " << appName << " config_file" << endl;
cout << " config_file - configuration file in Tcl format." << endl;
return 1;
}
try
{
// Initialization
confReader = new ExRootConfReader;
confReader->ReadFile(argv[1]);
modularDelphes = new Delphes("Delphes");
modularDelphes->SetConfReader(confReader);
factory = modularDelphes->GetFactory();
allParticleOutputArray = modularDelphes->ExportArray("allParticles");
stableParticleOutputArray = modularDelphes->ExportArray("stableParticles");
partonOutputArray = modularDelphes->ExportArray("partons");
modularDelphes->InitTask();
// fastjet definition
ClusterSequence::print_banner();
definition = new JetDefinition(antikt_algorithm, 0.5);
// Define your input candidates to fastjet (by default particle-flow objects).
// If you want pure calorimeter towers change "EFlowMerger/eflow" into "Calorimeter/towers":
inputArray = modularDelphes->ImportArray("EFlowMerger/eflow");
inputIterator = inputArray->MakeIterator();
// Event loop
for(event = 0; event < NEVENTS; ++event)
{
modularDelphes->Clear();
// convert EVENT input array into Delphes internal format
ConvertInput(event, factory, allParticleOutputArray, stableParticleOutputArray, partonOutputArray);
// run Delphes reconstruction
modularDelphes->ProcessTask();
inputList.clear();
inputIterator->Reset();
// pass delphes candidates to fastjet clustering
while((candidate = static_cast<Candidate*>(inputIterator->Next())))
{
momentum = candidate->Momentum;
jet = PseudoJet(momentum.Px(), momentum.Py(), momentum.Pz(), momentum.E());
inputList.push_back(jet);
}
// run clustering
ClusterSequence sequence(inputList, *definition);
outputList.clear();
outputList = sorted_by_pt(sequence.inclusive_jets(0.0));
// tell the user what was done
// - the description of the algorithm used
// - show the inclusive jets as
// {index, rapidity, phi, pt}
//----------------------------------------------------------
cout << "Ran " << definition->description() << endl;
// label the columns
printf("%5s %15s %15s %15s\n","jet #", "rapidity", "phi", "pt");
// print out the details for each jet
for (unsigned int i = 0; i < outputList.size(); i++) {
printf("%5u %15.8f %15.8f %15.8f\n",
i, outputList[i].rap(), outputList[i].phi(),
outputList[i].perp());
}
}
// Finalization
modularDelphes->FinishTask();
delete modularDelphes;
delete confReader;
return 0;
}
catch(runtime_error &e)
{
cerr << "** ERROR: " << e.what() << endl;
return 1;
}
}
StatusCode DelphesSaveGenJets::saveOutput(Delphes& delphes, const fcc::MCParticleCollection& mcParticles) {
// Create the collections
auto colGenJets = m_genJets.createAndPut();
auto colTaggedJets = m_taggedGenJets.createAndPut();
const TObjArray* delphesColl = delphes.ImportArray(m_delphesArrayName.c_str());
if (delphesColl == nullptr) {
warning() << "Delphes collection " << m_delphesArrayName << " not present. Skipping it." << endmsg;
return StatusCode::SUCCESS;
}
for(int j = 0; j < delphesColl->GetEntries(); ++j) {
auto cand = static_cast<Candidate *>(delphesColl->At(j));
// Jet info
auto jet = colGenJets->create();
auto bareJet = fcc::BareJet();
bareJet.area = -1;
bareJet.p4.px = cand->Momentum.Px();
bareJet.p4.py = cand->Momentum.Py();
bareJet.p4.pz = cand->Momentum.Pz();
bareJet.p4.mass = cand->Mass;
jet.core(bareJet);
// Flavor-tag info
auto flavorGenJet = colTaggedJets->create();
flavorGenJet.tag(cand->Flavor);
flavorGenJet.jet(jet);
// Debug: print FCC-EDM jets info
if (msgLevel() <= MSG::DEBUG) {
double energy = sqrt(jet.p4().px*jet.p4().px +
jet.p4().py*jet.p4().py +
jet.p4().pz*jet.p4().pz +
jet.p4().mass*jet.p4().mass);
debug() << "Gen Jet: "
<< " Id: " << std::setw(3) << j+1
<< " Flavor: " << std::setw(3) << flavorGenJet.tag()
<< std::scientific
<< " Px: " << std::setprecision(2) << std::setw(9) << jet.p4().px
<< " Py: " << std::setprecision(2) << std::setw(9) << jet.p4().py
<< " Pz: " << std::setprecision(2) << std::setw(9) << jet.p4().pz
<< " E: " << std::setprecision(2) << std::setw(9) << energy
<< " M: " << std::setprecision(2) << std::setw(9) << jet.p4().mass
<< std::fixed
<< std::endl;
}
// Reference to MC - Delphes holds references to all objects related to the Jet object,
// several relations might exist -> find "recursively" in a tree history the MC particle.
// Add index to the reference index field to avoid double counting
std::set<int> idRefMCPart; // Avoid double counting when referencingh MC particles
// Recursive procedure stops after the relation found is the one to MC particle and not to
// a particle object. If particle not related to MC particle (<0 value)
findJetPartMC(cand, mcParticles.size(), idRefMCPart);
// Debug: print variable
double totSimE = 0;
for (auto id : idRefMCPart) {
auto& mcParticle = mcParticles.at(id);
jet.addparticles(mcParticles.at(id));
// Debug: print FCC-EDM jet relation info
if (msgLevel() <= MSG::DEBUG) {
double recE = sqrt(jet.p4().px*jet.p4().px +
jet.p4().py*jet.p4().py +
jet.p4().pz*jet.p4().pz +
jet.p4().mass*jet.p4().mass);
double simE = sqrt(mcParticle.p4().px*mcParticle.p4().px +
mcParticle.p4().py*mcParticle.p4().py +
mcParticle.p4().pz*mcParticle.p4().pz +
mcParticle.p4().mass*mcParticle.p4().mass);
totSimE += simE;
debug() << " RefId: " << std::setw(3) << id+1
<< " Rel E: " << std::setprecision(2)
<< std::scientific
<< std::setw(9) << simE << " "
<< std::setw(9) << totSimE << " <-> "
<< std::setw(9) << recE
<< std::fixed
<< std::endl;
} // Debug
}
// Debug: print end-line
if (msgLevel() <= MSG::DEBUG) debug() << endmsg;
} // For - jets
return StatusCode::SUCCESS;
}
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[] = "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[])
{
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;
}
}
