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;
}
}
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;
}
}
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[])
{
if(argc != 3)
{
cout << " Usage: ./CaloGrid [detector card] [calo name]" << endl;
cout << "Example: ./CaloGrid cards/delphes_card_CMS.tcl ECal" << endl;
return 0;
}
TString card(argv[1]);
ExRootConfReader *confReader = new ExRootConfReader;
confReader->ReadFile(card);
std::vector<std::string> calorimeters_;
std::map<std::string, std::set<std::pair<Double_t, Int_t> > > caloBinning_;
std::string s(argv[2]);
std::replace(s.begin(), s.end(), ',', ' ');
std::istringstream stream(s);
std::string word;
while(stream >> word) calorimeters_.push_back(word);
caloBinning_.clear(); // calo binning
TCanvas c("", "", 1600, 838);
gPad->SetLeftMargin(0.16);
gPad->SetTopMargin(0.16);
gPad->SetBottomMargin(0.20);
gStyle->SetOptStat(0000000);
gStyle->SetTextFont(132);
TH2F h2("h2", "", 1, -6, 6, 1, 0, 6.28);
h2.GetXaxis()->SetTitle("#eta");
h2.GetYaxis()->SetTitle("#phi");
h2.GetXaxis()->SetTitleFont(132);
h2.GetYaxis()->SetTitleFont(132);
h2.GetZaxis()->SetTitleFont(132);
h2.GetXaxis()->SetLabelFont(132);
h2.GetYaxis()->SetLabelFont(132);
h2.GetXaxis()->SetTitleOffset(1.4);
h2.GetYaxis()->SetTitleOffset(1.1);
h2.GetXaxis()->SetLabelOffset(0.02);
h2.GetYaxis()->SetLabelOffset(0.02);
h2.GetXaxis()->SetTitleSize(0.06);
h2.GetYaxis()->SetTitleSize(0.06);
h2.GetXaxis()->SetLabelSize(0.06);
h2.GetYaxis()->SetLabelSize(0.06);
h2.GetXaxis()->SetTickLength(0.0);
h2.GetYaxis()->SetTickLength(0.0);
h2.Draw();
// fake loop just keeping it for convenience right now
for(std::vector<std::string>::const_iterator calo = calorimeters_.begin(); calo != calorimeters_.end(); ++calo)
{
//first entry is eta bin, second is number of phi bins
set<pair<Double_t, Int_t> > caloBinning;
ExRootConfParam paramEtaBins, paramPhiBins;
ExRootConfParam param = confReader->GetParam(Form("%s::EtaPhiBins", calo->c_str()));
Int_t size = param.GetSize();
for(int i = 0; i < size / 2; ++i)
{
paramEtaBins = param[i * 2];
paramPhiBins = param[i * 2 + 1];
assert(paramEtaBins.GetSize() == 1);
caloBinning.insert(std::make_pair(paramEtaBins[0].GetDouble(), paramPhiBins.GetSize() - 1));
}
caloBinning_[*calo] = caloBinning;
TLine *liney;
TLine *linex;
//loop over calo binning
std::set<std::pair<Double_t, Int_t> >::iterator it;
Int_t n = -1;
for(it = caloBinning.begin(); it != caloBinning.end(); ++it)
{
n++;
if(debug) cout << "-----------------------" << endl;
if(debug) cout << it->first << "," << it->second << endl;
liney = new TLine(it->first, 0, it->first, 6.28);
liney->SetLineColor(kRed + 3);
liney->Draw();
set<std::pair<Double_t, Int_t> >::iterator it2 = it;
it2--;
for(int j = 0; j <= it->second; j++)
{
Double_t yval0 = 0 + 6.28 * j / it->second;
if(debug) cout << it2->first << "," << yval0 << "," << it->first << "," << yval0 << endl;
linex = new TLine(it->first, yval0, it2->first, yval0);
linex->SetLineColor(kRed + 3);
linex->Draw();
}
}
}
TString text = TString(s);
TText *th1 = new TText(5.00, 6.45, text);
th1->SetTextAlign(31);
th1->SetTextFont(132);
th1->SetTextSize(0.075);
th1->Draw();
TString output = TString(s);
c.Print(output + ".png", "png");
c.Print(output + ".pdf", "pdf");
}