void parallelMergeClient()
{
// Client program which creates and fills 2 histograms and a TTree.
// Every 1000000 fills the histograms and TTree is send to the server which displays the histogram.
//
// To run this demo do the following:
// - Open at least 2 windows
// - Start ROOT in the first windows
// - Execute in the first window: .x fastMergeServer.C
// - Execute in the other windows: root.exe -b -l -q .x treeClient.C
// (You can put it in the background if wanted).
// If you want to run the hserv.C on a different host, just change
// "localhost" in the TSocket ctor below to the desired hostname.
//
//Author: Fons Rademakers, Philippe Canal
gBenchmark->Start("treeClient");
TParallelMergingFile *file = (TParallelMergingFile*)TFile::Open("mergedClient.root?pmerge=localhost:1095","RECREATE");
file->Write();
file->UploadAndReset(); // We do this early to get assigned an index.
UInt_t idx = file->fServerIdx; // This works on in ACLiC.
TH1 *hpx;
if (idx == 0) {
// Create the histogram
hpx = new TH1F("hpx","This is the px distribution",100,-4,4);
hpx->SetFillColor(48); // set nice fillcolor
} else {
hpx = new TH2F("hpxpy","py vs px",40,-4,4,40,-4,4);
}
Float_t px, py;
TTree *tree = new TTree("tree","tree");
tree->SetAutoFlush(4000000);
tree->Branch("px",&px);
tree->Branch("py",&py);
// Fill histogram randomly
gRandom->SetSeed();
const int kUPDATE = 1000000;
for (int i = 0; i < 25000000; ) {
gRandom->Rannor(px,py);
if (idx%2 == 0)
hpx->Fill(px);
else
hpx->Fill(px,py);
tree->Fill();
++i;
if (i && (i%kUPDATE) == 0) {
file->Write();
}
}
file->Write();
delete file;
gBenchmark->Show("treeClient");
}
// PValue for finding a local p-value as observed in 'bin' or worse
void ToyExperiments::printGlobalPValueOfLocalFluctuation(unsigned int bin, unsigned int nExperiments) const {
std::cout << "Determining global p-value for observed fluctuation in bin " << bin << " from " << nExperiments << " toy experiments ... " << std::flush;
// Find the predicted yields that correspond
// to the local p-value 'localPValue'
std::vector<unsigned int> limitYields = yields(localPValue(bin,observedYields_.at(bin)));
TH1* hIsAbovePValue = new TH1D("hIsAbovePValue","",2,0,2);
const double minCorr = findMinValidRandomNumberForCorrelatedUncertainties();
for(unsigned int p = 0; p < nExperiments; ++p) {
bool isAbovePValue = false;
double rCorr = rand_->Gaus(0.,1.);
while( rCorr <= minCorr ) {
rCorr = rand_->Gaus(0.,1.);
}
for(unsigned int b = 0; b < Parameters::nBins(); ++b) {
double prediction = -1.;
bool negativePrediction = true;
while( negativePrediction ) {
double rUncorr = rand_->Gaus(0.,1.);
double uncorrVar = rUncorr * uncorrelatedUncerts_.at(b);
double corrVar = rCorr * correlatedUncerts_.at(b);
prediction = meanPredictions_.at(b) + uncorrVar + corrVar;
if( prediction >= 0. ) {
negativePrediction = false;
}
}
double predictedYield = rand_->Poisson(prediction);
if( predictedYield >= limitYields.at(b) ) {
isAbovePValue = true;
break;
}
}
if( isAbovePValue ) {
hIsAbovePValue->Fill(1);
} else {
hIsAbovePValue->Fill(0);
}
}
std::cout << "ok" << std::endl;
double lpv = localPValue(bin,observedYields_.at(bin));
double gpUncorr = 1. - pow(1.-lpv,Parameters::nBins());
double gpCorr = hIsAbovePValue->Integral(2,2)/hIsAbovePValue->Integral(1,2);
std::cout << "\n\n----- Global p-value for observed fluctuation in bin " << bin << " -----" << std::endl;
std::cout << " local p-value : " << lpv << " (" << TMath::NormQuantile(1.-lpv) << "sig)" << std::endl;
std::cout << " global p-value (without correlations) : " << gpUncorr << " (" << TMath::NormQuantile(1.-gpUncorr) << "sig)" << std::endl;
std::cout << " global p-value (including correlations) : " << gpCorr << " (" << TMath::NormQuantile(1.-gpCorr) << "sig)" << std::endl;
}
TH1* fillHistogram(TTree* testTree, const std::string& varName, const std::string& selection, const std::string& frWeightName,
const std::string& histogramName, unsigned numBinsX, double xMin, double xMax)
{
std::cout << "<fillHistogram>:" << std::endl;
std::cout << " testTree = " << testTree << std::endl;
std::cout << " varName = " << varName << std::endl;
std::cout << " selection = " << selection << std::endl;
std::cout << " frWeightName = " << frWeightName << std::endl;
std::cout << " histogramName = " << histogramName << std::endl;
TH1* histogram = new TH1F(histogramName.data(), histogramName.data(), numBinsX, xMin, xMax);
histogram->Sumw2();
TFile* dummyOutputFile = new TFile("dummyOutputFile.root", "RECREATE");
TTree* selTree = ( selection != "" ) ? testTree->CopyTree(selection.data()) : testTree;
std::cout << " selTree = " << selTree << std::endl;
Float_t eventWeight = 1.;
selTree->SetBranchAddress("weight", &eventWeight);
Float_t var = 0.;
selTree->SetBranchAddress(varName.data(), &var);
Float_t frWeight = 1.;
if ( frWeightName != "" ) {
std::cout << "--> setting branch-address of fake-rate weight..." << std::endl;
selTree->SetBranchAddress(frWeightName.data(), &frWeight);
}
int numEntries = selTree->GetEntries();
std::cout << "--> numEntries = " << numEntries << std::endl;
//if ( maxEntriesToProcess != -1 ) numEntries = TMath::Min(numEntries, maxEntriesToProcess);
for ( int iEntry = 0 ; iEntry < numEntries; ++iEntry ) {
selTree->GetEvent(iEntry);
//std::cout << "iEntry = " << iEntry << ": var = " << var << ", frWeight = " << frWeight << std::endl;
if ( frWeightName != "" ) {
if ( TMath::Abs(frWeight) < 1. ) // some entries have weight O(-100)
// --> indication of technical problem with k-NearestNeighbour tree ?
histogram->Fill(var, frWeight*eventWeight);
} else {
histogram->Fill(var, eventWeight);
}
}
delete dummyOutputFile;
return histogram;
}
int main (int argc, char *argv[])
{
LineStream ls;
char *line;
char *pos;
Stringa buffer;
if (argc != 2) {
usage ("%s <file.intraOffsets>");
}
TH1 *his = new TH1D ("","Intra-read distribution",1000,0,1000);
TCanvas *canv = new TCanvas("","canvas",1200,400);
ls = ls_createFromFile (argv[1]);
while (line = ls_nextLine (ls)) {
his->Fill (atoi (line));
}
ls_destroy (ls);
his->Draw();
his->GetXaxis()->SetLabelSize (0.04);
his->GetYaxis()->SetLabelSize (0.04);
buffer = stringCreate (100);
pos = strchr (argv[1],'.');
if (pos == NULL) {
die ("Expected <file.intraOffsets>: %s",argv[1]);
}
*pos = '\0';
stringPrintf (buffer,"%s_intraDistribution.jpg",argv[1]);
canv->Print (string (buffer),"jpg");
stringDestroy (buffer);
return 0;
}
void Kin2Txt() {
AliRunLoader* rl = AliRunLoader::Open("galice.root");
rl->LoadKinematics();
rl->LoadHeader();
TH1* hM = new TH1D("hM", "TreeK;M#(){#pi^{+}#pi^{-}} #(){GeV/#it{c}^{2}}", 100, 0., 2.);
TH1* hPt = new TH1D("hPt", "TreeK;P_{T}#(){#pi^{+}#pi^{-}} #(){GeV/#it{c}}", 100, 0., 1.);
TH1* hY = new TH1D("hY", "TreeK;Y#(){#pi^{+}#pi^{-}}", 160,-8., 8.);
std::ofstream ofs("rho0.txt");
AliStack *stack = NULL;
TParticle *part = NULL;
TLorentzVector v[2], vSum;
for (Int_t i=0, n(rl->GetNumberOfEvents()); i<n; ++i) {
rl->GetEvent(i);
stack = rl->Stack();
Int_t nPrimary(0);
for (Int_t j(0), m(stack->GetNtrack()); j<m; ++j) {
part = stack->Particle(j);
if (part->IsPrimary())
part->Momentum(v[nPrimary++]);
}
if (nPrimary != 2) {
Printf("Error: nPrimary=%d != 2", nPrimary);
continue;
}
vSum = v[0] + v[1];
hM->Fill(vSum.M());
hPt->Fill(vSum.Perp());
hY->Fill(vSum.Rapidity());
ofs << std::fixed << std::setprecision(4)
<< vSum.M() << " " << vSum.Perp() << " " << vSum.Rapidity() << " "
<< v[0].Eta() << " " << v[0].Px() << " " << v[0].Py() << " " << v[0].Pz() << " "
<< v[1].Eta() << " " << v[1].Px() << " " << v[1].Py() << " " << v[1].Pz()
<< std::endl;
}
hM->Draw();
c1->SaveAs("TreeK.pdf(");
hPt->Draw();
c1->SaveAs("TreeK.pdf");
hY->Draw();
c1->SaveAs("TreeK.pdf)");
}
void analyzer()
{
TString processName = "ZJets";
TFile* f = TFile::Open(Form("hist_%s.root", processName.Data()), "recreate");
// Create chain of root trees
TChain chain("DelphesMA5tune");
//kisti
//chain.Add("/cms/home/tjkim/fcnc/sample/ZToLL50-0Jet_sm-no_masses/events_*.root");
//hep
chain.Add("/Users/tjkim/Work/fcnc/samples/ZToLL50-0Jet_sm-no_masses/events_*.root");
// Create object of class ExRootTreeReader
ExRootTreeReader *treeReader = new ExRootTreeReader(&chain);
Long64_t numberOfEntries = treeReader->GetEntries();
// Get pointers to branches used in this analysis
TClonesArray *branchMuon = treeReader->UseBranch("DelphesMA5tuneMuon");
// Book histograms
TH1 *histDiMuonMass = new TH1F("dimuon_mass","Di-Muon Invariant Mass (GeV)",100, 50, 150);
// Loop over all events
for(Int_t entry = 0; entry < numberOfEntries; ++entry)
{
// Load selected branches with data from specified event
treeReader->ReadEntry(entry);
int nmuon = 0;
for( int i = 0; i < branchMuon->GetEntries(); i++)
{
Muon *muon = (Muon*) branchMuon->At(i);
if( muon->PT <= 20 || abs(muon->Eta) >= 2.4 ) continue;
nmuon = nmuon + 1 ;
}
if( nmuon >= 2){
Muon *mu1 = (Muon*) branchMuon->At(0);
Muon *mu2 = (Muon*) branchMuon->At(1);
// Plot di-muon invariant mass
histDiMuonMass->Fill(((mu1->P4()) + (mu2->P4())).M());
}
}
// Show resulting histograms
histDiMuonMass->Write();
f->Close();
}
void testTDime(Int_t nev = 100) {
gSystem->Load("libEVGEN");
gSystem->Load("libTDime");
gSystem->Load("libdime");
TDime* dime = new TDime();
dime->SetEnergyCMS(7000.0);
dime->SetYRange(-2.0, 2.0); // Set rapidity range of mesons
dime->SetMinPt(0.1); // Minimum pT of mesons
dime->Initialize();
// (pi+pi-) histograms
TH1* hM = new TH1D("hM", "DIME #pi^{+}#pi^{-};M_{#pi^{+}#pi^{-}} #[]{GeV/#it{c}^{2}}", 100, 0.0, 5.0);
TClonesArray* particles = new TClonesArray("TParticle", 6);
TParticle* part = NULL;
TLorentzVector v[2];
TLorentzVector vSum;
// Event loop
for (Int_t i = 0; i < nev; ++i) {
dime->GenerateEvent();
Int_t np = dime->ImportParticles(particles, "All");
printf("\n DIME Event %d: Imported %3d particles \n", i, np);
Int_t nPrimary = 0;
// Loop over pion (j = 4,5) tracks
for (Int_t j = 4; j < 6; ++j) {
part = (TParticle*) particles->At(j); // Choose the particle
part->Print();
part->Momentum(v[nPrimary]); // Copy content to v
nPrimary++;
}
//particles.Clear();
// 4-vector sum
vSum = v[0] + v[1];
// Fill pi+pi- histograms
hM->Fill(vSum.M());
}
// Save plots as pdf
hM->Draw(); c1->SaveAs("massTDime.pdf");
}
void fill(const NTupleReader& tr, const double weight)
{
const int& nSearchBin = tr.getVar<int>("nSearchBin");
const double& met = tr.getVar<double>("met");
const double& best_had_brJet_MT2 = tr.getVar<double>("best_had_brJet_MT2");
const int& cntCSVS = tr.getVar<int>("cntCSVS");
const int& nTopCandSortedCnt = tr.getVar<int>("nTopCandSortedCnt");
const bool& passBaseline = tr.getVar<bool>("passBaseline");
met_->Fill(met, weight);
mt2_->Fill(best_had_brJet_MT2, weight);
nt_->Fill(nTopCandSortedCnt, weight);
nb_->Fill(cntCSVS, weight);
if(passBaseline)
{
baseline_met_->Fill(met, weight);
baseline_mt2_->Fill(best_had_brJet_MT2, weight);
baseline_nt_->Fill(nTopCandSortedCnt, weight);
baseline_nb_->Fill(cntCSVS, weight);
baseline_nSearchBin_->Fill(nSearchBin, weight);
}
}
void TTimeHists::Fill(EHist hist)
{
for (Long_t n = 0; n < fNum; ++n) {
NextValues();
if (fgDebug > 1) {
printf("%ld: fill %s", n, hist == kHist? (fDim < 4 ? "hist" : "arr") : "sparse");
for (Int_t d = 0; d < fDim; ++d)
printf("[%g]", fValue[d]);
printf("\n");
}
if (hist == kHist) {
switch (fDim) {
case 1: fHist->Fill(fValue[0]); break;
case 2: ((TH2F*)fHist)->Fill(fValue[0], fValue[1]); break;
case 3: ((TH3F*)fHist)->Fill(fValue[0], fValue[1], fValue[2]); break;
default: fHn->Fill(fValue); break;
}
} else {
fSparse->Fill(fValue);
}
}
}
void ConnectToServer(const TInetAddress *hostb, Int_t port)
{
// Called by the Bonjour resolver with the host and port to which
// we can connect.
// Connect only once...
TBonjourResolver *resolver = (TBonjourResolver*) gTQSender;
TInetAddress host = *hostb;
delete resolver;
printf("ConnectToServer: host = %s, port = %d\n", host.GetHostName(), port);
//--- Here starts original hclient.C code ---
// Open connection to server
TSocket *sock = new TSocket(host.GetHostName(), port);
// Wait till we get the start message
char str[32];
sock->Recv(str, 32);
// server tells us who we are
int idx = !strcmp(str, "go 0") ? 0 : 1;
Float_t messlen = 0;
Float_t cmesslen = 0;
if (idx == 1)
sock->SetCompressionLevel(1);
TH1 *hpx;
if (idx == 0) {
// Create the histogram
hpx = new TH1F("hpx","This is the px distribution",100,-4,4);
hpx->SetFillColor(48); // set nice fillcolor
} else {
hpx = new TH2F("hpxpy","py vs px",40,-4,4,40,-4,4);
}
TMessage::EnableSchemaEvolutionForAll(gEvo);
TMessage mess(kMESS_OBJECT);
//TMessage mess(kMESS_OBJECT | kMESS_ACK);
// Fill histogram randomly
gRandom->SetSeed();
Float_t px, py;
const int kUPDATE = 1000;
for (int i = 0; i < 25000; i++) {
gRandom->Rannor(px,py);
if (idx == 0)
hpx->Fill(px);
else
hpx->Fill(px,py);
if (i && (i%kUPDATE) == 0) {
mess.Reset(); // re-use TMessage object
mess.WriteObject(hpx); // write object in message buffer
sock->Send(mess); // send message
messlen += mess.Length();
cmesslen += mess.CompLength();
}
}
sock->Send("Finished"); // tell server we are finished
if (cmesslen > 0)
printf("Average compression ratio: %g\n", messlen/cmesslen);
gBenchmark->Show("hclient");
// Close the socket
sock->Close();
}
bool TauAnalysisSelector::process(Long64_t entry) {
double weight = 1.0;
if(!fPuWeightName.empty()) {
weight *= fPuWeight->value();
}
fEventCounter.setWeight(weight);
cAll.increment();
if(fIsEmbedded) {
weight *= fGeneratorWeight->value();
fEventCounter.setWeight(weight);
}
cGeneratorWeight.increment();
/*
std::cout << "FOO Event " << fEventInfo.event() << ":" << fEventInfo.lumi() << ":" << fEventInfo.run()
<< " electronVeto passed? " << fElectronVetoPassed->value()
<< std::endl;
if( (fEventInfo.event() == 10069461 && fEventInfo.lumi() == 33572) ||
(fEventInfo.event() == 10086951 && fEventInfo.lumi() == 33630) ||
(fEventInfo.event() == 101065527 && fEventInfo.lumi() == 336953) ||
(fEventInfo.event() == 101450418 && fEventInfo.lumi() == 338236) ||
(fEventInfo.event() == 101460111 && fEventInfo.lumi() == 338268) ) {
std::cout << "BAR Event " << fEventInfo.event() << ":" << fEventInfo.lumi() << ":" << fEventInfo.run()
<< " electronVeto passed? " << fElectronVetoPassed->value()
<< " Nelectrons " << fElectrons.size()
<< std::endl;
for(size_t i=0; i<fElectrons.size(); ++i) {
ElectronCollection::Electron electron = fElectrons.get(i);
std::cout << " Electron " << i
<< " pt " << electron.p4().Pt()
<< " eta " << electron.p4().Eta()
<< " hasGsfTrack " << electron.hasGsfTrack()
<< " hasSuperCluster " << electron.hasSuperCluster()
<< " supercluster eta " << electron.superClusterEta()
<< " passIdVeto " << electron.cutBasedIdVeto()
<< std::endl;
}
}
if(!fElectronVetoPassed->value()) return false;
cElectronVeto.increment();
*/
// Tau BR
if(fIsEmbedded && fEmbeddingNormalizationMode == kIDTriggerEfficiencyTauBR) {
weight *= (1-0.357); // from my thesis, which took the numbers from PDG
fEventCounter.setWeight(weight);
}
cTauBRWeight.increment();
// MC status
std::vector<GenParticleCollection::GenParticle> genTaus;
GenParticleCollection::GenParticle theGenTau;
if(isMC()) {
bool canContinue = true;
if(fIsEmbedded) {
canContinue = findGenTaus(fGenTausEmbedded, 2212, &genTaus);
canContinue = canContinue && genTaus.size() != 0;
}
else
canContinue = findGenTaus(fGenTaus, 6, &genTaus);
if(!canContinue)
return false;
}
cGenTauFound.increment();
if(isMC() && fMCTauMultiplicity != kMCTauNone) {
size_t ntaus = genTaus.size();
if(fIsEmbedded) {
std::vector<GenParticleCollection::GenParticle> genTausOrig;
findGenTaus(fGenTaus, 6, &genTausOrig);
ntaus = genTausOrig.size();
}
if(fIsEmbedded) {
// For embedded the embedded tau is counted as one
if(fMCTauMultiplicity == kMCTauZeroTaus) return true;
if(fMCTauMultiplicity == kMCTauOneTau && ntaus != 0) return true;
if(fMCTauMultiplicity == kMCTauTwoTaus && ntaus != 1) return true;
if(fMCTauMultiplicity == kMCTauMoreThanTwoTaus && ntaus < 2) return true;
}
else {
if(fMCTauMultiplicity == kMCTauZeroTaus && ntaus != 0) return true;
if(fMCTauMultiplicity == kMCTauOneTau && ntaus != 1) return true;
if(fMCTauMultiplicity == kMCTauTwoTaus && ntaus != 2) return true;
if(fMCTauMultiplicity == kMCTauMoreThanTwoTaus && ntaus < 3) return true;
}
if(genTaus.size() > 0)
theGenTau = genTaus[0];
}
cTauMCSelection.increment();
bool originalMuonIsWMu = false;
EmbeddingMuonCollection::Muon embeddingMuon;
if(fIsEmbedded) {
if(fMuons.size() != 1)
throw std::runtime_error("Embedding muon collection size is not 1");
embeddingMuon = fMuons.get(0);
if(embeddingMuon.p4().Pt() < 41) return true;
//std::cout << "Muon pt " << muon.p4().Pt() << std::endl;
originalMuonIsWMu = std::abs(embeddingMuon.pdgId()) == 13 && std::abs(embeddingMuon.motherPdgId()) == 24 && std::abs(embeddingMuon.grandMotherPdgId()) == 6;
if(!originalMuonIsWMu) return true;
}
cOnlyWMu.increment();
// Per-event correction for W->tau->mu
if(fIsEmbedded && fEmbeddingWTauMuWeights) {
embeddingMuon.ensureValidity();
int bin = fEmbeddingWTauMuWeights->FindBin(embeddingMuon.p4().Pt());
//std::cout << embeddingMuon.p4().Pt() << " " << bin << std::endl;
weight *= fEmbeddingWTauMuWeights->GetBinContent(bin);
fEventCounter.setWeight(weight);
}
cWTauMuWeight.increment();
// Muon trigger efficiency weighting
if(fIsEmbedded && (fEmbeddingNormalizationMode == kIDTriggerEfficiency || fEmbeddingNormalizationMode == kIDTriggerEfficiencyTauBR)) {
weight *= 1/embeddingMuon.triggerEfficiency();
fEventCounter.setWeight(weight);
}
cTriggerEffWeight.increment();
// Muon ID efficiency weighting
if(fIsEmbedded) {
weight *= 1/embeddingMuon.idEfficiency();
fEventCounter.setWeight(weight);
}
cIdEffWeight.increment();
// Weighting by arbitrary histogram, given in constructor argument
if(fIsEmbedded && fEmbeddingMuonWeights) {
embeddingMuon.ensureValidity();
int bin = fEmbeddingMuonWeights->FindFixBin(embeddingMuon.p4().Pt());
weight *= fEmbeddingMuonWeights->GetBinContent(bin);
fEventCounter.setWeight(weight);
}
cMuonWeight.increment();
// Jet selection
/*
size_t njets = fJets.size();
size_t nselectedjets = 0;
for(size_t i=0; i<njets; ++i) {
JetCollection::Jet jet = fJets.get(i);
// Clean selected muon from jet collection
bool matches = false;
double DR = ROOT::Math::VectorUtil::DeltaR(fMuons.get(0).p4(), jet.p4());
if(DR < 0.1) {
matches = true;
}
if(matches) continue;
// Count jets
++nselectedjets;
}
if(nselectedjets < 3) return true;
*/
cJetSelection.increment();
if(fSelectedVertexCount->value() <= 0) return true;
cPrimaryVertex.increment();
std::vector<TauCollection::Tau> selectedTaus;
std::vector<TauCollection::Tau> tmp;
if(fTaus.size() < 1) return true;
cAllTauCandidates.increment();
// Pre pT cut (for some reason in the region pT < 10 there is significantly more normal than embedded)
for(size_t i=0; i<fTaus.size(); ++i) {
TauCollection::Tau tau = fTaus.get(i);
if(tau.p4().Pt() < 10) continue;
if(!TauID::isolation(tau)) continue;
//if(isMC() && !fIsEmbedded && tau.genMatchP4().Pt() <= 41) continue; // temporary hack
selectedTaus.push_back(tau);
if(!fIsEmbedded) break; // select only the first gen tau
}
if(selectedTaus.empty()) return true;
cPrePtCut.increment();
// Decay mode finding
bool atLeastOneIsolated = false;
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::decayModeFinding(tau)) continue;
if(TauID::isolation(tau)) {
atLeastOneIsolated = true;
hTau_AfterDecayModeFindingIsolation.fill(tau.p4(), weight);
}
tmp.push_back(tau);
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cDecayModeFinding.increment();
if(atLeastOneIsolated) {
if(theGenTau.isValid()) hGenTau_AfterDecayModeFindingIsolation.fill(theGenTau.p4(), weight);
hVertexCount_AfterDecayModeFindingIsolation->Fill(fVertexCount->value(), weight);
}
// Eta cut
atLeastOneIsolated = false;
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::eta(tau)) continue;
if(TauID::isolation(tau)) {
atLeastOneIsolated = true;
hTau_AfterEtaCutIsolation.fill(tau.p4(), weight);
}
tmp.push_back(tau);
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cEtaCut.increment();
if(atLeastOneIsolated) {
hGenTau_AfterEtaCutIsolation.fill(theGenTau.p4(), weight);
hVertexCount_AfterEtaCutIsolation->Fill(fVertexCount->value(), weight);
}
// Pt cut
atLeastOneIsolated = false;
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::pt(tau)) continue;
if(TauID::isolation(tau)) {
atLeastOneIsolated = true;
hTau_AfterPtCutIsolation.fill(tau.p4(), weight);
hTauLeadingTrackPt_AfterPtCutIsolation->Fill(tau.leadPFChargedHadrCandP4().Pt(), weight);
}
tmp.push_back(tau);
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cPtCut.increment();
if(atLeastOneIsolated) {
hGenTau_AfterPtCutIsolation.fill(theGenTau.p4(), weight);
hVertexCount_AfterPtCutIsolation->Fill(fVertexCount->value(), weight);
}
// Leading track pt
atLeastOneIsolated = false;
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::leadingChargedHadrCandPt(tau)) continue;
tmp.push_back(tau);
if(TauID::isolation(tau)) {
atLeastOneIsolated = true;
hTau_AfterLeadingTrackPtCutIsolation.fill(tau.p4(), weight);
}
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cLeadingTrackPtCut.increment();
if(atLeastOneIsolated) {
hGenTau_AfterLeadingTrackPtCutIsolation.fill(theGenTau.p4(), weight);
}
// ECAL fiducial cuts
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::ecalCracks(tau)) continue;
tmp.push_back(tau);
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cEcalCracks.increment();
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::ecalGap(tau)) continue;
tmp.push_back(tau);
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cEcalGap.increment();
// Against electron
atLeastOneIsolated = false;
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::againstElectron(tau)) continue;
tmp.push_back(tau);
if(TauID::isolation(tau)) {
atLeastOneIsolated = true;
hTau_AfterAgainstElectronIsolation.fill(tau.p4(), weight);
}
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cAgainstElectron.increment();
if(atLeastOneIsolated) {
hGenTau_AfterAgainstElectronIsolation.fill(theGenTau.p4(), weight);
}
// Against muon
atLeastOneIsolated = false;
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::againstMuon(tau)) continue;
tmp.push_back(tau);
if(TauID::isolation(tau)) {
atLeastOneIsolated = true;
hTau_AfterAgainstMuonIsolation.fill(tau.p4(), weight);
}
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cAgainstMuon.increment();
if(atLeastOneIsolated) {
hGenTau_AfterAgainstMuonIsolation.fill(theGenTau.p4(), weight);
}
// Tau candidate selection finished
// Isolation
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::isolation(tau)) continue;
int decayMode = tau.decayMode();
int fill = -1;
if (decayMode <= 2) fill = decayMode; // 0 = pi+, 1 = pi+pi0, 2 = pi+pi0pi0
else if(decayMode == 10) fill = 3; // pi+pi-pi+
else fill = 4; // Other
hTau_AfterIsolation.fill(tau.p4(), weight);
hTauDecayModeAll_AfterIsolation->Fill(decayMode, weight);
hTauDecayMode_AfterIsolation->Fill(fill, weight);
tmp.push_back(tau);
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cIsolation.increment();
hVertexCount_AfterIsolation->Fill(fVertexCount->value(), weight);
if(theGenTau.isValid()) hGenTau_AfterIsolation.fill(theGenTau.p4(), weight);
// One prong
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::oneProng(tau)) continue;
tmp.push_back(tau);
hTau_AfterOneProng.fill(tau.p4(), weight);
hTauP_AfterOneProng->Fill(tau.p4().P(), weight);
hTauLeadingTrackPt_AfterOneProng->Fill(tau.leadPFChargedHadrCandP4().Pt(), weight);
hTauLeadingTrackP_AfterOneProng->Fill(tau.leadPFChargedHadrCandP4().P(), weight);
hTauRtau_AfterOneProng->Fill(tau.rtau(), weight);
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cOneProng.increment();
hGenTau_AfterOneProng.fill(theGenTau.p4(), weight);
hVertexCount_AfterOneProng->Fill(fVertexCount->value(), weight);
// Rtau
for(size_t i=0; i<selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
if(!TauID::rtau(tau)) continue;
hTau_AfterRtau.fill(tau.p4(), weight);
tmp.push_back(tau);
}
selectedTaus.swap(tmp);
tmp.clear();
if(selectedTaus.empty()) return true;
cRtau.increment();
hVertexCount_AfterRtau->Fill(fVertexCount->value(), weight);
if(theGenTau.isValid()) hGenTau_AfterRtau.fill(theGenTau.p4(), weight);
// Tau ID finished
// Trigger
/*
if(fIsEmbedded) {
if(!fMuTriggerPassed->value()) return true;
}
*/
cMuTrigger.increment();
if(false) {
std::cout << "Event " << fEventInfo.event() << ":" << fEventInfo.lumi() << ":" << fEventInfo.run() << std::endl;
for(size_t i=0; i< selectedTaus.size(); ++i) {
TauCollection::Tau& tau = selectedTaus[i];
std::cout << " selected tau pt " << tau.p4().Pt() << " eta " << tau.p4().Eta() << " phi " << tau.p4().Phi() << std::endl;
if(fIsEmbedded) {
embeddingMuon.ensureValidity();
double DR = ROOT::Math::VectorUtil::DeltaR(tau.p4(), embeddingMuon.p4());
if(DR < 0.5) {
std::cout << " matched to embedding muon, DR " << DR << std::endl;
}
}
for(size_t j=0; j<fGenTaus.size(); ++j) {
GenParticleCollection::GenParticle gen = fGenTaus.get(j);
double DR = ROOT::Math::VectorUtil::DeltaR(tau.p4(), gen.p4());
if(DR < 0.5) {
std::cout << " matched to generator tau, DR " << DR
<< " mother " << gen.motherPdgId()
<< " grandmother " << gen.grandMotherPdgId()
<< std::endl;
}
}
}
}
return true;
}
void MassPlotterSingleTop::singleTopAnalysis(TList* allCuts, Long64_t nevents ,TString myfileName ){
TopUtilities topUtils ;
int lumi = 0;
TIter nextcut(allCuts);
TObject *objcut;
std::vector<TString> alllabels;
while( objcut = nextcut() ){
ExtendedCut* thecut = (ExtendedCut*)objcut ;
alllabels.push_back( thecut->Name );
}
//alllabels.push_back( "NoCut" );
alllabels.push_back( "Trigger" );
//alllabels.push_back( "MuonSelection" );
//alllabels.push_back( "MuonVeto1" );
//alllabels.push_back( "MuonVeto" );
alllabels.push_back( "== 1#mu" );
alllabels.push_back( "== 2-Jets" );
alllabels.push_back( "== 1-bJet" );
alllabels.push_back( "MT >50 GeV" );
//alllabels.push_back( "j'-bVeto" );
alllabels.push_back( "mtop" );
//cout << alllabels.size() << endl;
ExtendedObjectProperty cutflowtable("" , "cutflowtable" , "1" , alllabels.size() , 0 , alllabels.size() , "2", {}, &alllabels );
ExtendedObjectProperty cutflowtablew1("" , "cutflowtablew1" , "1" , alllabels.size() , 0 , alllabels.size() , "2", {}, &alllabels );
TString fileName = fOutputDir;
if(!fileName.EndsWith("/")) fileName += "/";
Util::MakeOutputDir(fileName);
bool printEventIds = false;
vector< ofstream* > EventIdFiles;
if(printEventIds){
for( int i = 0 ; i < alllabels.size() ; i++ ){
ofstream* filetxt = new ofstream(fileName + "/IPM_" + myfileName + "_step" + boost::lexical_cast<string>(i) + ".txt" );
EventIdFiles.push_back( filetxt );
}
}
ExtendedObjectProperty nJetsBeforeCut("LeptonVeto" , "nJets" , "1" , 8 , 0 , 8 , "2", {});
ExtendedObjectProperty nJets20_47("OneBjet" , "nJets20_47" , "1" , 8 , 0 , 8 , "2", {});
ExtendedObjectProperty nJets20_24("OneBjet" , "nJets20_24" , "1" , 8 , 0 , 8 , "2", {});
ExtendedObjectProperty nbJets("Jets" , "nbJets" , "1" , 3 , 0 , 3 , "2", {});
ExtendedObjectProperty MTBeforeCut("OneBjetNoMT" , "MT" , "1" , 30 , 0 , 300 , "2", {});
ExtendedObjectProperty nPVBeforeCutsUnCorr("nPVBeforeCutsUnCorr" , "nPVBeforeCutsUnCorr" , "1" , 100 , 0 , 100 , "2", {});
ExtendedObjectProperty nPVBeforeCuts("nPVBeforeCuts" , "nPVBeforeCuts" , "1" , 100 , 0 , 100 , "2", {});
ExtendedObjectProperty nPVAfterCutsUnCorr("nPVAfterCutsUnCorr" , "nPVAfterCutsUnCorr" , "1" , 100 , 0 , 100 , "2", {});
ExtendedObjectProperty nPVAfterCuts("nPVAfterCuts" , "nPVAfterCuts" , "1" , 100 , 0 , 100 , "2", {});
ExtendedObjectProperty TopMass("OneBjet" , "TopMass" , "1" , 30 , 100 , 400 , "2", {});
ExtendedObjectProperty jprimeEta("OneBjet" , "jPrimeEta" , "1" , 10 , 0 , 5.0 , "2", {});
ExtendedObjectProperty jprimeEtaSB("SideBand" , "jPrimeEtaSB" , "1" , 10 , 0 , 5.0 , "2", {});
ExtendedObjectProperty jprimePt("OneBjet" , "jPrimePt" , "1" , 30 , 30 , 330 , "2", {});
ExtendedObjectProperty muPtOneB("OneBjet" , "muPt" , "1" , 20 , 20 , 120 , "2", {});
ExtendedObjectProperty muCharge("OneBjet" , "muCharge" , "1" , 40 , -2 , 2 , "2", {});
ExtendedObjectProperty muEtaOneB("OneBjet" , "muEta" , "1" , 10 , -2.5 , 2.5 , "2", {});
ExtendedObjectProperty METOneBSR("OneBjet" , "MET_SR" , "1" , 20 , 0 , 200 , "2", {});
ExtendedObjectProperty METOneBSB("OneBjet" , "MET_SB" , "1" , 20 , 0 , 200 , "2", {});
ExtendedObjectProperty METOneBAll("OneBjet" , "MET_ALL" , "1" , 20 , 0 , 200 , "2", {});
ExtendedObjectProperty bPtOneB("OneBjet" , "bPt" , "1" , 30 , 30 , 330 , "2", {});
ExtendedObjectProperty bEtaOneB("OneBjet" , "bEta" , "1" , 10 , 0 , 5.0 , "2", {});
ExtendedObjectProperty nonbCSV("OneBjet" , "jpCSV" , "1" , 20 , 0 , 1.0 , "2", {});
ExtendedObjectProperty nLbjets1EJ24("1EJ24" , "nLbJets_1EJ24" , "1" , 2 , 0 , 2 , "2", {});
ExtendedObjectProperty nTbjets1EJ24("1EJ24" , "nTbJets_1EJ24" , "1" , 2 , 0 , 2 , "2", {});
ExtendedObjectProperty nLbjets2EJ24("2EJ24" , "nLbJets_2EJ24" , "1" , 3 , 0 , 3 , "2", {});
ExtendedObjectProperty nTbjets2EJ24("2EJ24" , "nTbJets_2EJ24" , "1" , 3 , 0 , 3 , "2", {});
ExtendedObjectProperty nLbjets3EJ24("3EJ24" , "nLbJets_3EJ24" , "1" , 4 , 0 , 4 , "2", {});
ExtendedObjectProperty nTbjets3EJ24("3EJ24" , "nTbJets_3EJ24" , "1" , 4 , 0 , 4 , "2", {});
ExtendedObjectProperty nLbjets4EJ24("4EJ24" , "nLbJets_4EJ24" , "1" , 5 , 0 , 5 , "2", {});
ExtendedObjectProperty nTbjets4EJ24("4EJ24" , "nTbJets_4EJ24" , "1" , 5 , 0 , 5 , "2", {});
ExtendedObjectProperty nLbjets1EJ47("1EJ47" , "nLbJets_1EJ47" , "1" , 2 , 0 , 2 , "2", {});
ExtendedObjectProperty nTbjets1EJ47("1EJ47" , "nTbJets_1EJ47" , "1" , 2 , 0 , 2 , "2", {});
ExtendedObjectProperty nLbjets2EJ47("2EJ47" , "nLbJets_2EJ47" , "1" , 3 , 0 , 3 , "2", {});
ExtendedObjectProperty nTbjets2EJ47("2EJ47" , "nTbJets_2EJ47" , "1" , 3 , 0 , 3 , "2", {});
ExtendedObjectProperty nLbjets3EJ47("3EJ47" , "nLbJets_3EJ47" , "1" , 4 , 0 , 4 , "2", {});
ExtendedObjectProperty nTbjets3EJ47("3EJ47" , "nTbJets_3EJ47" , "1" , 4 , 0 , 4 , "2", {});
ExtendedObjectProperty nLbjets4EJ47("4EJ47" , "nLbJets_4EJ47" , "1" , 5 , 0 , 5 , "2", {});
ExtendedObjectProperty nTbjets4EJ47("4EJ47" , "nTbJets_4EJ47" , "1" , 5 , 0 , 5 , "2", {});
TH1* hTopMass = new TH1D("hTopMass" , "Top Mass" , 500 , 0 , 500 );
TH1* hTopMassEtaJ = new TH2D( "hTopMassEtaJ" , "Top Mass" , 500 , 0 , 500 , 20 , 0 , 5.0 );
TH1* hEtajPDFScales[102];
double ScalesPDF[102];
double CurrentPDFWeights[102];
for(int i=0 ; i < 102 ; i++){
TString s(to_string(i));
hEtajPDFScales[i] = new TH1D( TString("hEtaJp_PDF")+s , "" , 10 , 0 , 5.0 );
ScalesPDF[i] = 0 ;
CurrentPDFWeights[i] = 0;
}
TH1* hEtajWScales[9];
double WScalesTotal[9];
double CurrentLHEWeights[9];
for(int i=0; i < 9; i++){
TString s(to_string(i));
hEtajWScales[i] = new TH1D( TString("hEtaJp_")+s , "" , 10 , 0 , 5.0 );
WScalesTotal[i] = 0 ;
CurrentLHEWeights[i] = 0;
}
std::vector<ExtendedObjectProperty*> allProps = {&cutflowtable, &cutflowtablew1 , &nJetsBeforeCut , &nbJets , &MTBeforeCut, &TopMass , &jprimeEta , &jprimeEtaSB , &jprimePt , &muPtOneB, &muCharge, &muEtaOneB , &METOneBSR ,&METOneBSB , &METOneBAll , & bPtOneB , &bEtaOneB , &nonbCSV ,&nJets20_24, &nJets20_47,&nPVAfterCuts, &nPVBeforeCuts , &nPVAfterCutsUnCorr , &nPVBeforeCutsUnCorr};
std::vector<ExtendedObjectProperty*> JbJOptimizationProps = {&nLbjets1EJ24,&nTbjets1EJ24,&nLbjets2EJ24,&nTbjets2EJ24,&nLbjets3EJ24,&nTbjets3EJ24,&nLbjets4EJ24,&nTbjets4EJ24,&nLbjets1EJ47,&nTbjets1EJ47,&nLbjets2EJ47,&nTbjets2EJ47,&nLbjets3EJ47,&nTbjets3EJ47,&nLbjets4EJ47,&nTbjets4EJ47};
nextcut.Reset();
//codes for 2j0t selection
TFile *theTreeFile = NULL;
if(IsQCD==1)
theTreeFile = new TFile( (fileName+ myfileName + "_Trees.root" ).Data(), "RECREATE");
double MT_QCD_Tree , TOPMASS_QCD_Tree , MuIso_QCD_Tree , Weight_QCD_Tree;
TTree* theQCD_Tree = NULL;
//end of 2j0t
for(int ii = 0; ii < fSamples.size(); ii++){
int data = 0;
sample Sample = fSamples[ii];
TEventList* list = 0;
if(Sample.type == "data"){
data = 1;
}else
lumi = Sample.lumi;
if( theTreeFile ){
TString treename = Sample.sname ;
if( data )
treename = "Data";
if( theTreeFile->Get( treename ) ){
theQCD_Tree = (TTree*) (theTreeFile->Get( treename )) ;
}else{
theTreeFile->cd();
theQCD_Tree = new TTree( treename , treename + " tree for QCD shape/normalization studies" );
theQCD_Tree->Branch( "MT/D" , &MT_QCD_Tree );
theQCD_Tree->Branch( "TOPMASS/D" , &TOPMASS_QCD_Tree );
theQCD_Tree->Branch( "MuIso/D" , &MuIso_QCD_Tree );
theQCD_Tree->Branch( "Weight/D" , &Weight_QCD_Tree );
}
}
double Weight = Sample.xsection * Sample.kfact * Sample.lumi / (Sample.nevents*Sample.PU_avg_weight);
//Weight = 1.0;
if(data == 1)
Weight = 1.0;
Sample.Print(Weight);
SingleTopTree fTree( Sample.tree );
Sample.tree->SetBranchStatus("*", 1);
string lastFileName = "";
Long64_t nentries = Sample.tree->GetEntries();
Long64_t maxloop = min(nentries, nevents);
int counter = 0;
double EventsIsPSeudoData ;
int cutPassCounter = 0;
for (Long64_t jentry=0; jentry<maxloop;jentry++, counter++) {
Sample.tree->GetEntry(jentry);
// //cout << fTree.Event_EventNumber << endl;
// if( !(fTree.Event_EventNumber == 11112683 || fTree.Event_EventNumber == 11112881 ) ){
// //cout << " " ;
// continue;
// }
// else{
// cutPassCounter ++ ;
// cout << cutPassCounter << " : " << fTree.Event_EventNumber << " : " << endl;
// }
EventsIsPSeudoData = PSeudoDataRandom->Uniform();
if( lastFileName.compare( ((TChain*)Sample.tree)->GetFile()->GetName() ) != 0 ) {
for(auto prop : allProps)
prop->SetTree( Sample.tree , Sample.type, Sample.sname );
for(auto prop2 : JbJOptimizationProps )
prop2->SetTree( Sample.tree , Sample.type, Sample.sname );
nextcut.Reset();
while( objcut = nextcut() ){
ExtendedCut* thecut = (ExtendedCut*)objcut ;
thecut->SetTree( Sample.tree , Sample.name , Sample.sname , Sample.type , Sample.xsection, Sample.nevents, Sample.kfact , Sample.PU_avg_weight);
}
lastFileName = ((TChain*)Sample.tree)->GetFile()->GetName() ;
cout << "new file : " << lastFileName << endl;
}
if ( counter == 100000 ){
fprintf(stdout, "\rProcessed events: %6d of %6d ", jentry + 1, nentries);
fflush(stdout);
counter = 0;
}
nextcut.Reset();
double weight = Weight;
if( !data ){
weight *= fTree.Event_puWeight ;
}
if( Sample.UseLHEWeight ){
//cout << "SIGNAL" << endl;
weight *= fTree.Event_LHEWeightSign ;
// if(fTree.Event_LHEWeightSign < 0.0)
// cout << fTree.Event_LHEWeightSign << endl;
}
#ifdef SingleTopTreeLHEWeights_h
for( int i = 0 ; i < 102 ; i++ ){
CurrentPDFWeights[i] = fTree.GetPDFWeight(i)/fabs(fTree.Event_LHEWeight) ;
ScalesPDF[i] += CurrentPDFWeights[i] ;
}
if( Sample.name == "WJets" || Sample.name == "Signal" ){
if(fTree.GetLHEWeight(0) != fTree.Event_LHEWeight0) cout << "Wrong GetLHEWeight(0) Value" << endl;
if(fTree.GetLHEWeight(1) != fTree.Event_LHEWeight1) cout << "Wrong GetLHEWeight(1) Value" << endl;
if(fTree.GetLHEWeight(2) != fTree.Event_LHEWeight2) cout << "Wrong GetLHEWeight(2) Value" << endl;
if(fTree.GetLHEWeight(3) != fTree.Event_LHEWeight3) cout << "Wrong GetLHEWeight(3) Value" << endl;
if(fTree.GetLHEWeight(4) != fTree.Event_LHEWeight4) cout << "Wrong GetLHEWeight(4) Value" << endl;
if(fTree.GetLHEWeight(5) != fTree.Event_LHEWeight5) cout << "Wrong GetLHEWeight(5) Value" << endl;
if(fTree.GetLHEWeight(6) != fTree.Event_LHEWeight6) cout << "Wrong GetLHEWeight(6) Value" << endl;
if(fTree.GetLHEWeight(7) != fTree.Event_LHEWeight7) cout << "Wrong GetLHEWeight(7) Value" << endl;
if(fTree.GetLHEWeight(8) != fTree.Event_LHEWeight8) cout << "Wrong GetLHEWeight(8) Value" << endl;
// CurrentLHEWeights[0] = fTree.Event_LHEWeight /fabs(fTree.Event_LHEWeight) ;
// CurrentLHEWeights[1] = fTree.Event_LHEWeight1/fabs(fTree.Event_LHEWeight) ;
// CurrentLHEWeights[2] = fTree.Event_LHEWeight2/fabs(fTree.Event_LHEWeight) ;
// CurrentLHEWeights[3] = fTree.Event_LHEWeight3/fabs(fTree.Event_LHEWeight) ;
// CurrentLHEWeights[4] = fTree.Event_LHEWeight4/fabs(fTree.Event_LHEWeight) ;
// CurrentLHEWeights[5] = fTree.Event_LHEWeight5/fabs(fTree.Event_LHEWeight) ;
// CurrentLHEWeights[6] = fTree.Event_LHEWeight6/fabs(fTree.Event_LHEWeight) ;
// CurrentLHEWeights[7] = fTree.Event_LHEWeight7/fabs(fTree.Event_LHEWeight) ;
// CurrentLHEWeights[8] = fTree.Event_LHEWeight8/fabs(fTree.Event_LHEWeight) ;
for(int i = 0 ; i<9 ;i++){
CurrentLHEWeights[i] = fTree.GetLHEWeight(i)/fabs(fTree.Event_LHEWeight) ;
WScalesTotal[i] += CurrentLHEWeights[i];
}
}
#endif
double cutindex = 0.5;
bool pass=true;
while( objcut = nextcut() ){
ExtendedCut* thecut = (ExtendedCut*)objcut ;
pass &= thecut->Pass(jentry , weight);
if(! pass ){
break;
}else{
if( isfinite (weight) ){
cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
}
else
cout << "non-finite weight : " << weight << endl;
}
cutindex+=1.0;
}
if(! pass)
continue;
int cut = 0;
//cout << alllabels[ int(cutindex) ] << endl;
// cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
// cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
// cutindex ++ ;
// if( data && !(fTree.Event_passesHLT_IsoMu20_eta2p1_v2 > 0.5) )
// continue;
// if( !data && !(fTree.Event_passesHLT_IsoMu20_eta2p1_v1 > 0.5) )
// continue;
nPVBeforeCutsUnCorr.Fill( fTree.Event_nPV , weight/fTree.Event_puWeight , false , true );
nPVBeforeCuts.Fill( fTree.Event_nPV , weight , false, true);
// if( printEventIds )
// (*(EventIdFiles[cutindex])) << fTree.Event_EventNumber << endl;
// cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
// cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
// cutindex ++ ;
if( data && !(fTree.Event_passesHLT_IsoMu20_v2 > 0.5 || fTree.Event_passesHLT_IsoMu20_v1 > 0.5 || fTree.Event_passesHLT_IsoMu20_v3 > 0.5) )
continue;
if(!data && !(fTree.Event_passesHLT_IsoMu20_v1 > 0.5) )
continue;
if( printEventIds )
(*(EventIdFiles[cutindex])) << fTree.Event_EventNumber << endl;
cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
cutindex ++ ;
//cout << "nMuons : " << fTree.muons_size << endl;
int tightMuIndex =-1;
int nonTightMuIndex = -1;
int nLooseMuos = 0;
int nTightMuons = 0;
int nTightNonIsoMuons = 0;
for( int imu=0 ; imu < fTree.muons_size ; imu++ ){
// cout << imu << " : " << fTree.muons_Pt[imu] << "-" << fTree.muons_Eta[imu] << "-"
// << fTree.muons_IsTightMuon[imu] << "-" << fTree.muons_Iso04[imu] << endl;
bool isTight = false;
if( fTree.muons_Pt[imu] > 22.0 &&
fabs(fTree.muons_Eta[imu]) < 2.1 &&
fTree.muons_IsTightMuon[imu] > 0.5 ){
if( fTree.muons_Iso04[imu] < 0.06 ){
isTight = true;
nTightMuons ++;
if( tightMuIndex == -1 )
tightMuIndex = imu;
}else if( fTree.muons_Iso04[imu] < 0.15 ){
nTightNonIsoMuons ++;
if( nonTightMuIndex == -1 )
nonTightMuIndex = imu;
}
}
if( ! isTight )
if( fTree.muons_Pt[ imu ] > 10.0 &&
fTree.muons_IsLooseMuon[ imu ] > 0.5 &&
fabs(fTree.muons_Eta[imu]) < 2.5 &&
fTree.muons_Iso04[imu] < 0.20 ){
nLooseMuos++;
}
}
if(IsQCD){
nLooseMuos = nTightMuons ;
nTightMuons = nTightNonIsoMuons ;
tightMuIndex = nonTightMuIndex ;
}
if( nTightMuons != 1 )
continue;
bool isiso = true;
if( nLooseMuos > 0 )
continue;
#ifdef MUONCHARGEP
if(fTree.muons_Charge[tightMuIndex] < 0)
continue;
#endif
#ifdef MUONCHARGEN
if(fTree.muons_Charge[tightMuIndex] > 0)
continue;
#endif
// if( printEventIds )
// (*(EventIdFiles[cutindex])) << (fTree.Event_EventNumber) << endl ;
// cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
// cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
// cutindex ++ ;
int nLooseElectrons = 0;
for( int iele = 0 ; iele < fTree.electrons_size;iele ++ ){
if( fTree.electrons_Pt[iele] > 20 &&
fabs(fTree.electrons_Eta[iele]) < 2.5 &&
( fabs(fTree.electrons_Eta[iele]) < 1.4442 || fabs(fTree.electrons_Eta[iele]) > 1.566) &&
fTree.electrons_vidVeto[iele] > 0.5 )
nLooseElectrons++;
}
if( nLooseElectrons > 0 )
continue;
if( printEventIds )
(*(EventIdFiles[cutindex])) << (fTree.Event_EventNumber) << endl ;
cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
cutindex ++ ;
int j1index = -1;
int j2index = -1;
int j3index = -1;
int nJets = 0 ;
int howManyBJets = 0;
int bjIndex = -1;
int bj2Index = -1;
int jprimeIndex ;
int nJetsPt20_47 = 0;
int nJetsPt20_24 = 0;
int nLbJetsPt20 = 0;
int nTbJetsPt20 = 0;
TLorentzVector muon;
muon.SetPtEtaPhiE( fTree.muons_Pt[tightMuIndex] , fTree.muons_Eta[tightMuIndex] , fTree.muons_Phi[tightMuIndex] , fTree.muons_E[tightMuIndex] );
if( muon.Energy() == 0.0 )
cout << "ZERO???" <<endl;
for( int jid = 0 ; jid < fTree.jetsAK4_size ; jid++ ){
float NHF = fTree.jetsAK4_JetID_neutralHadronEnergyFraction[jid] ;
float NEMF = fTree.jetsAK4_JetID_neutralEmEnergyFraction[jid] ;
float NumConst = fTree.jetsAK4_JetID_numberOfDaughters[jid] ;
float eta = fTree.jetsAK4_Eta[jid] ;
float CHF = fTree.jetsAK4_JetID_chargedHadronEnergyFraction[jid] ;
float CHM = fTree.jetsAK4_JetID_chargedMultiplicity[jid] ;
float CEMF = fTree.jetsAK4_JetID_chargedEmEnergyFraction[jid] ;
float NumNeutralParticle = fTree.jetsAK4_JetID_neutralMultiplicity[jid] ;
bool looseid ;
if( abs(eta)<=3.0 ) {
looseid = (NHF<0.99 && NEMF<0.99 && NumConst>1) && ((abs(eta)<=2.4 && CHF>0 && CHM>0 && CEMF<0.99) || abs(eta)>2.4) ;
}
else
looseid = (NEMF<0.90 && NumNeutralParticle>10) ;
if( fTree.jetsAK4_CorrPt[jid] > 20 &&
fabs( fTree.jetsAK4_Eta[jid] ) < 4.7 &&
looseid
){
TLorentzVector jet;
jet.SetPtEtaPhiE( fTree.jetsAK4_CorrPt[jid] , fTree.jetsAK4_Eta[jid] , fTree.jetsAK4_Phi[jid] , fTree.jetsAK4_CorrE[jid] );
double DR = muon.DeltaR( jet );
if ( DR > 0.3 ){
if( fTree.jetsAK4_CorrPt[jid] <= 40 ){
nJetsPt20_47 ++ ;
if( fabs( fTree.jetsAK4_Eta[jid] ) < 2.4 ){
nJetsPt20_24 ++;
if( fTree.jetsAK4_CSV[jid] > 0.97 )
nTbJetsPt20++;
else if( fTree.jetsAK4_CSV[jid] > 0.605 )
nLbJetsPt20++;
}
continue;
}
nJets++;
if( nJets == 1 )
j1index = jid ;
else if(nJets == 2 )
j2index = jid ;
else if( nJets == 3 )
j3index = jid ;
if( fTree.jetsAK4_IsCSVT[jid] == true && fabs( fTree.jetsAK4_Eta[jid] ) <= 2.4 ){
howManyBJets ++;
if(howManyBJets==1)
bjIndex = jid ;
else if(howManyBJets==2)
bj2Index = jid ;
}else
jprimeIndex = jid ;
}
}
}
nJetsBeforeCut.Fill( nJets , weight , EventsIsPSeudoData < fabs(weight) , isiso );
if (nJets != NUMBEROFJETS)
continue;
if( printEventIds )
(*(EventIdFiles[cutindex])) << (fTree.Event_EventNumber) << endl ;
cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
cutindex ++ ;
nbJets.Fill( howManyBJets , weight , EventsIsPSeudoData < fabs(weight) , isiso);
if( howManyBJets != NUMBEROFBJETS )
continue;
if( !data ){
if( NUMBEROFBJETS == 2 )
weight *= fTree.Event_bWeight2CSVT ;
else if (NUMBEROFBJETS == 1 )
weight *= fTree.Event_bWeight1CSVT ;
}
//weight = 1.0;
if( printEventIds )
(*(EventIdFiles[cutindex])) << (fTree.Event_EventNumber) << endl ;
cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
cutindex ++ ;
double MT = sqrt( 2*fTree.met_Pt* fTree.muons_Pt[tightMuIndex]*(1-TMath::Cos( Util::DeltaPhi(fTree.met_Phi , fTree.muons_Phi[tightMuIndex]) ) ) ) ;
MTBeforeCut.Fill( MT , weight , EventsIsPSeudoData < fabs(weight) , isiso );
// if( fTree.met_Pt < 45 )
// continue;
if( MT < 50 && (NUMBEROFBJETS == 1 && NUMBEROFJETS == 2) && !IsQCD )
continue;
if( printEventIds )
(*(EventIdFiles[cutindex])) << (fTree.Event_EventNumber) << endl ;
cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
cutindex ++ ;
nonbCSV.Fill( fTree.jetsAK4_CSV[jprimeIndex] , weight , EventsIsPSeudoData < fabs(weight) , isiso);
// if( fTree.jetsAK4_CSV[jprimeIndex] > 0.605 )
// continue;
// if( printEventIds )
// (*(EventIdFiles[cutindex])) << (fTree.Event_EventNumber) << endl ;
// cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
// cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
// cutindex ++ ;
nJets20_47.Fill( nJetsPt20_47 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nJets20_24.Fill( nJetsPt20_24 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
if(nJetsPt20_24 < 2){
nLbjets1EJ24.Fill( nLbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nTbjets1EJ24.Fill( nTbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
if(nJetsPt20_24 < 3){
nLbjets2EJ24.Fill( nLbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nTbjets2EJ24.Fill( nTbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
if(nJetsPt20_24 < 4){
nLbjets3EJ24.Fill( nLbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nTbjets3EJ24.Fill( nTbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
if(nJetsPt20_24 < 5){
nLbjets4EJ24.Fill( nLbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nTbjets4EJ24.Fill( nTbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
if(nJetsPt20_47 < 2){
nLbjets1EJ47.Fill( nLbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nTbjets1EJ47.Fill( nTbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
if(nJetsPt20_47 < 3){
nLbjets2EJ47.Fill( nLbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nTbjets2EJ47.Fill( nTbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
if(nJetsPt20_47 < 4){
nLbjets3EJ47.Fill( nLbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nTbjets3EJ47.Fill( nTbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
if(nJetsPt20_47 < 5){
nLbjets4EJ47.Fill( nLbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
nTbjets4EJ47.Fill( nTbJetsPt20 , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
if( NUMBEROFBJETS == 2 )
if( fTree.jetsAK4_CSV[bj2Index] > fTree.jetsAK4_CSV[bjIndex] )
std::swap( bj2Index , bjIndex );
//int jprimeIndex = (bjIndex == j1index) ? j2index : j1index ;
TLorentzVector muLV;
muLV.SetPtEtaPhiE( fTree.muons_Pt[tightMuIndex] , fTree.muons_Eta[tightMuIndex] , fTree.muons_Phi[ tightMuIndex ] , fTree.muons_E[tightMuIndex] );
TLorentzVector bjetLV;
bjetLV.SetPtEtaPhiE( fTree.jetsAK4_CorrPt[ bjIndex ] , fTree.jetsAK4_Eta[ bjIndex ] , fTree.jetsAK4_Phi[ bjIndex ] , fTree.jetsAK4_CorrE[ bjIndex ] ) ;
double topMass = topUtils.top4Momentum( muLV , bjetLV , fTree.met_Px , fTree.met_Py ).mass();
TopMass.Fill( topMass , weight , EventsIsPSeudoData < fabs(weight) , isiso ); //fTree.resolvedTopSemiLep_Mass[0]
MT_QCD_Tree = MT;
TOPMASS_QCD_Tree = topMass ;
MuIso_QCD_Tree = fTree.muons_Iso04[tightMuIndex];
Weight_QCD_Tree = weight ;
if( IsQCD )
theQCD_Tree->Fill();
if( (130. < topMass && topMass < 225.) || NUMBEROFBJETS == 2 ){
nPVAfterCutsUnCorr.Fill( fTree.Event_nPV , weight/fTree.Event_puWeight , EventsIsPSeudoData < fabs(weight) , isiso );
nPVAfterCuts.Fill( fTree.Event_nPV , weight , EventsIsPSeudoData < fabs(weight) , isiso );
#ifdef SingleTopTreeLHEWeights_h
for(int i = 0 ; i< 102 ; i++){
hEtajPDFScales[i]->Fill( fabs( fTree.jetsAK4_Eta[jprimeIndex] ) , weight*fabs( CurrentPDFWeights[i] ) );
}
if( Sample.name == "WJets" || Sample.name == "Signal"){
for(int i=0;i<9;i++)
hEtajWScales[i]->Fill( fabs( fTree.jetsAK4_Eta[jprimeIndex] ) , weight*fabs( CurrentLHEWeights[i] ) );
}
#endif
jprimeEta.Fill( fabs( fTree.jetsAK4_Eta[jprimeIndex] ) , weight , EventsIsPSeudoData < fabs(weight) , isiso);
jprimePt.Fill( fTree.jetsAK4_CorrPt[jprimeIndex] , weight , EventsIsPSeudoData < fabs(weight) , isiso);
muPtOneB.Fill( fTree.muons_Pt[tightMuIndex] , weight , EventsIsPSeudoData < fabs(weight) , isiso);
muCharge.Fill( fTree.muons_Charge[tightMuIndex] , weight , EventsIsPSeudoData < fabs(weight) , isiso);
muEtaOneB.Fill( fabs(fTree.muons_Eta[tightMuIndex]) , weight , EventsIsPSeudoData < fabs(weight), isiso );
METOneBSR.Fill( fTree.met_Pt , weight , EventsIsPSeudoData < fabs(weight) , isiso);
bPtOneB.Fill( fTree.jetsAK4_CorrPt[bjIndex] , weight , EventsIsPSeudoData < fabs(weight), isiso );
bEtaOneB.Fill(fabs( fTree.jetsAK4_Eta[bjIndex] ) , weight , EventsIsPSeudoData < fabs(weight), isiso );
if( printEventIds )
(*(EventIdFiles[cutindex])) << (fTree.Event_EventNumber) << endl ;
cutflowtable.Fill( cutindex , weight , EventsIsPSeudoData < fabs(weight) );
cutflowtablew1.Fill( cutindex , weight/fabs(weight) , EventsIsPSeudoData < fabs(weight) );
cutindex++;
}else{
jprimeEtaSB.Fill( fabs( fTree.jetsAK4_Eta[jprimeIndex] ) , weight , EventsIsPSeudoData < fabs(weight) , isiso );
METOneBSB.Fill( fTree.met_Pt , weight , EventsIsPSeudoData < fabs(weight) , isiso);
}
METOneBAll.Fill( fTree.met_Pt , weight , EventsIsPSeudoData < fabs(weight) , isiso);
if(Sample.name == "Signal" )
hTopMass->Fill( topMass , weight );
if(Sample.name == "WJets")
hTopMassEtaJ->Fill( topMass ,fabs( fTree.jetsAK4_Eta[jprimeIndex] ) );
}
theQCD_Tree->Write();
}
theTreeFile->Close();
// TString fileName = fOutputDir;
// if(!fileName.EndsWith("/")) fileName += "/";
// Util::MakeOutputDir(fileName);
fileName += myfileName + ".root" ;
TFile *theFile = new TFile(fileName.Data(), "RECREATE");
nonbCSV.CalcSig( 0 , 0 , -1 , 0 ) ;
nonbCSV.CalcSig( 0 , 4 , -1 , 0.1);
nonbCSV.CalcSig( 0 , 2 , -1 , 0 ) ;
nJets20_24.CalcSig( 0 , 0 , -1 , 0 ) ;
nJets20_24.CalcSig( 0 , 4 , -1 , 0.1 ) ;
nJets20_24.CalcSig( 0 , 2 , -1 , 0 ) ;
nJets20_47.CalcSig( 0 , 0 , -1 , 0 ) ;
nJets20_47.CalcSig( 0 , 4 , -1 , 0.1 ) ;
nJets20_47.CalcSig( 0 , 2 , -1 , 0 ) ;
muCharge.CalcSig( 0 , 0 , -1 , 0 ) ;
muCharge.CalcSig( 0 , 4 , -1 , 0.1 ) ;
muCharge.CalcSig( 0 , 2 , -1 , 0 ) ;
muCharge.CalcSig( 1 , 0 , -1 , 0 ) ;
muCharge.CalcSig( 1 , 4 , -1 , 0.1 ) ;
muCharge.CalcSig( 1 , 2 , -1 , 0 ) ;
for(auto prop : allProps)
prop->Write( theFile , 1000 );
#ifdef SingleTopTreeLHEWeights_h
TDirectory* dirWScales = theFile->mkdir("WJScales");
dirWScales->cd();
for(int i=0;i<9;i++){
cout << "WScalesTotal[i]" << WScalesTotal[i] << "," << WScalesTotal[0]/WScalesTotal[i] << endl;
hEtajWScales[i]->Scale( WScalesTotal[0]/WScalesTotal[i] );
hEtajWScales[i]->Write();
}
TDirectory* dirPDFScales = theFile->mkdir("PDFScales");
dirPDFScales->cd();
for(int i=0;i<102;i++){
cout << "PDFScales[i]" << ScalesPDF[i] << "," << WScalesTotal[0]/ScalesPDF[i] << endl;
hEtajPDFScales[i]->Scale( WScalesTotal[0]/ScalesPDF[i] );
hEtajPDFScales[i]->Write();
}
#endif
TDirectory* dir2 = theFile->mkdir("JbJOptimizationProps");
dir2->cd();
for(auto prop2 : JbJOptimizationProps){
prop2->CalcSig( 0 , 0 , -1 , 0 ) ;
prop2->CalcSig( 0 , 4 , -1 , 0.1 ) ;
prop2->CalcSig( 0 , 2 , -1 , 0 ) ;
prop2->Write( dir2 , 1000 );
}
theFile->cd();
hTopMass->Write();
hTopMassEtaJ->Write();
//cutflowtable.Print("cutflowtable");
theFile->Close();
if( printEventIds )
for( auto a : EventIdFiles ){
a->close();
}
}
int main(int argc, char *argv[]){
/////////////////////////////////////
if (argc != 6)
{
std::cout << "Please enter something like: ./run \"filelist_WJets_PU20bx25_100_200.txt\" \"WJets_PU20bx25_100_200\" \"Results\" \"00\" \"0\" " << std::endl;
return EXIT_FAILURE;
}
//get the inputs from user
const string InRootList = argv[1];
const string subSampleKey = argv[2];
const string Outdir = argv[3];
const string inputnumber = argv[4];
const string verbosity = argv[5];
//////////////////////////////////////
int verbose = atoi(verbosity.c_str());
//some varaibles
char filenames[500];
vector<string> filesVec;
ifstream fin(InRootList.c_str());
TChain *sample_AUX = new TChain("TreeMaker2/PreSelection");
char tempname[200];
char histname[200];
const double deltaRMax = 0.1;
const double deltaPtMax = 0.2;
map<string,int> binMap = utils2::BinMap_NoB();
int totNbins=binMap.size();
map<string,int> binMap_mht_nj = utils2::BinMap_mht_nj();
int totNbins_mht_nj=binMap_mht_nj.size();
TH1* hAccAll = new TH1D("hAccAll","Acceptance -- All",totNbins_mht_nj,1,totNbins_mht_nj+1);
TH1* hIsoRecoAll = new TH1D("hIsoRecoAll","Efficiency -- All",totNbins,1,totNbins+1);
TH1* hAccPass = new TH1D("hAccPass","Acceptance -- Pass",totNbins_mht_nj,1,totNbins_mht_nj+1);
TH1* hIsoRecoPass = new TH1D("hIsoRecoPass","Efficiency -- Pass",totNbins,1,totNbins+1);
hAccAll->Sumw2();
hIsoRecoAll->Sumw2();
hAccPass->Sumw2();
hIsoRecoPass->Sumw2();
int TauResponse_nBins=4;
vector<TH1*> vec_resp;
TFile * resp_file = new TFile("TauHad/HadTau_TauResponseTemplates_TTbar_Elog195WithDirectionalTemplates.root","R");
for(int i=0; i<TauResponse_nBins; i++){
sprintf(histname,"hTauResp_%d",i);
vec_resp.push_back( (TH1D*) resp_file->Get( histname )->Clone() );
}
///read the file names from the .txt files and load them to a vector.
while(fin.getline(filenames, 500) ){filesVec.push_back(filenames);}
cout<< "\nProcessing " << subSampleKey << " ... " << endl;
for(unsigned int in=0; in<filesVec.size(); in++){ sample_AUX->Add(filesVec.at(in).c_str()); }
// --- Analyse the events --------------------------------------------
Selection * sel = new Selection();
Utils * utils = new Utils();
// Interface to the event content
Events * evt = new Events(sample_AUX, subSampleKey,verbose);
// Loop over the events (tree entries)
int eventN=0;
while( evt->loadNext() ){
// if(eventN>10000)break;
eventN++;
// Through out an event that contains HTjets with bad id
if(evt->JetId()==0)continue;
//printf("\n@@@@@@@@@@@@@@@@@@@@@@@@@@ \n event: %d \n Njet: %d HT: %g MHT: %g dphi1: %g dphi2: %g dphi3: %g \n ",eventN-1,evt->nJets(),evt->ht(),evt->mht(),evt->deltaPhi1(),evt->deltaPhi2(),evt->deltaPhi3()); //Ahmad3
// Apply the NJets baseline-cut
if( !sel->Njet_4(evt->nJets()) ) continue;
// Apply the HT and MHT baseline-cuts
if( !sel->ht_500(evt->ht()) ) continue;
if( !sel->mht_200(evt->mht()) ) continue;
// Apply the delta-phi cuts
// if( !sel->dphi(evt->nJets(),evt->minDeltaPhiN()) ) continue;
if( !sel->dphi(evt->nJets(),evt->deltaPhi1(),evt->deltaPhi2(),evt->deltaPhi3(),evt->deltaPhi4()) ) continue;
if(verbose!=0)printf("\n############ \n event: %d \n ",eventN-1);
double genMuPt=0.;
double genMuEta=-99.;
double genMuPhi=-99.;
int firstMuId=0;
vector<TVector3> genMuonVec;
TVector3 temp3vec;
genMuonVec.clear();
bool isMuon = false;
for(int i=0; i< evt->GenMuPtVec_().size(); i++){
if(evt->GenMuFromTauVec_()[i]==0){
genMuPt = evt->GenMuPtVec_().at(i);
genMuEta = evt->GenMuEtaVec_().at(i);
genMuPhi = evt->GenMuPhiVec_().at(i);
isMuon=true;
temp3vec.SetPtEtaPhi(genMuPt,genMuEta,genMuPhi);
genMuonVec.push_back(temp3vec);
}
if(verbose!=0){
printf("Muon # %d, pt: %g, eta: %g, phi: %g \n ",i,genMuPt,genMuEta,genMuPhi);
}
break; // if more than one muon exist, pick the energetic one.
}
// ask for exactly one muon
if( evt->GenMuPtVec_().size() > 1 ) continue;
if( !( isMuon ) ) continue;
// recompute ht mht njet
double scale;
if(genMuPt >=20.)scale = utils->getRandom(genMuPt,vec_resp );
else scale = utils->getRandom(20.,vec_resp );
double simTauJetPt = scale * genMuPt;
double simTauJetEta = genMuEta;
double simTauJetPhi = genMuPhi;
// 3Vec of muon and scaledMu
TVector3 SimTauJet3Vec,NewTauJet3Vec,Muon3Vec;
SimTauJet3Vec.SetPtEtaPhi(simTauJetPt,simTauJetEta,simTauJetPhi);
Muon3Vec.SetPtEtaPhi(genMuPt,genMuEta,genMuPhi);
// New ht and mht
vector<TVector3> HT3JetVec,MHT3JetVec;
HT3JetVec.clear();
MHT3JetVec.clear();
TVector3 temp3Vec;
int slimJetIdx=-1;
utils->findMatchedObject(slimJetIdx,genMuEta,genMuPhi,evt->slimJetPtVec_(),evt->slimJetEtaVec_(), evt->slimJetPhiVec_(),deltaRMax,verbose);
// If there is no match, add the tau jet as a new one
if(slimJetIdx==-1){
NewTauJet3Vec=SimTauJet3Vec;
if(NewTauJet3Vec.Pt()>30. && fabs(NewTauJet3Vec.Eta())<2.4)HT3JetVec.push_back(NewTauJet3Vec);
if(NewTauJet3Vec.Pt()>30. && fabs(NewTauJet3Vec.Eta())<5.)MHT3JetVec.push_back(NewTauJet3Vec);
}
for(int i=0;i<evt->slimJetPtVec_().size();i++){
if(i!=slimJetIdx){
temp3Vec.SetPtEtaPhi(evt->slimJetPtVec_()[i],evt->slimJetEtaVec_()[i],evt->slimJetPhiVec_()[i]);
if(evt->slimJetPtVec_()[i]>30. && fabs(evt->slimJetEtaVec_()[i])<2.4)HT3JetVec.push_back(temp3Vec);
if(evt->slimJetPtVec_()[i]>30. && fabs(evt->slimJetEtaVec_()[i])<5.)MHT3JetVec.push_back(temp3Vec);
}
else if(i==slimJetIdx){
temp3Vec.SetPtEtaPhi(evt->slimJetPtVec_()[i],evt->slimJetEtaVec_()[i],evt->slimJetPhiVec_()[i]);
NewTauJet3Vec=temp3Vec-Muon3Vec+SimTauJet3Vec;
if(NewTauJet3Vec.Pt()>30. && fabs(NewTauJet3Vec.Eta())<2.4)HT3JetVec.push_back(NewTauJet3Vec);
if(NewTauJet3Vec.Pt()>30. && fabs(NewTauJet3Vec.Eta())<5.)MHT3JetVec.push_back(NewTauJet3Vec);
}
}
// Order the HT3JetVec and MHT3JetVec based on their pT
HT3JetVec = utils->Order_the_Vec(HT3JetVec);
MHT3JetVec = utils->Order_the_Vec(MHT3JetVec);
double newHT=0,newMHT=0,newMHTPhi=-1;
TVector3 newMHT3Vec;
for(int i=0;i<HT3JetVec.size();i++){
newHT+=HT3JetVec[i].Pt();
}
for(int i=0;i<MHT3JetVec.size();i++){
newMHT3Vec-=MHT3JetVec[i];
}
newMHT=newMHT3Vec.Pt();
newMHTPhi=newMHT3Vec.Phi();
//New #Jet
int newNJet = HT3JetVec.size();
if(verbose==1)printf("newNJet: %d \n ",newNJet);
// Acceptance determination 1: Counter for all events
// with muons at generator level
hAccAll->Fill( binMap_mht_nj[utils2::findBin_mht_nj(evt->nJets(),evt->mht()).c_str()] );
// hAccAll->Fill( binMap_mht_nj[utils2::findBin_mht_nj(newNJet,newMHT).c_str()] ); // this doesn't work good
// Check if generator-level muon is in acceptance
if( genMuPt > LeptonAcceptance::muonPtMin() && std::abs(genMuEta) < LeptonAcceptance::muonEtaMax() ) {
if(verbose!=0)printf("Muon is in acceptance \n ");
// Acceptance determination 2: Counter for only those events
// with generator-level muons inside acceptance
// hAccPass->Fill( binMap[utils2::findBin(cntNJetsPt30Eta24,nbtag,HT,template_mht).c_str()] );
hAccPass->Fill( binMap_mht_nj[utils2::findBin_mht_nj(evt->nJets(),evt->mht()).c_str()] );
// hAccPass->Fill( binMap_mht_nj[utils2::findBin_mht_nj(newNJet,newMHT).c_str()] );
// Reconstruction-efficiency determination 1: Counter for all events
// with generator-level muons inside acceptance, regardless of whether
// the muon has also been reconstructed or not.
// hIsoRecoAll->Fill( binMap[utils2::findBin(cntNJetsPt30Eta24,nbtag,HT,template_mht).c_str()]);
hIsoRecoAll->Fill( binMap[utils2::findBin_NoB(evt->nJets(),evt->ht(),evt->mht()).c_str()]);
// Check if the muon has been reconstructed: check if a reconstructed
// muon is present in the event that matches the generator-level muon
// Isolation-efficiency determination 1: Counter for all events with a
// reconstructed muon that has a generator-level muon match inside the
// the acceptance, regardless of whether the reconstructed muon is also
// isolated or not.
//if( evt->MuPtVec_().size()>0 )printf(" RecoMu--> Pt: %g eta: %g phi: %g deltaRMax: %g ",evt->MuPtVec_()[0],evt->MuEtaVec_()[0],evt->MuPhiVec_()[0],deltaRMax); // Ahmad3
//else cout << " Muon size is 0 \n " ;
// in R and in pt
int matchedMuonIdx = -1;
if(evt->MuPtVec_().size()>0 && utils->findMatchedObject(matchedMuonIdx,genMuEta,genMuPhi,evt->MuPtVec_(),evt->MuEtaVec_(),evt->MuPhiVec_(),deltaRMax,verbose) ) {
// Muon is reconstructed
const double relDeltaPtMu = std::abs(genMuPt - evt->MuPtVec_().at(matchedMuonIdx) ) / evt->MuPtVec_().at(matchedMuonIdx) ;
if(verbose!=0)printf(" relDeltaPtMu: %g \n ",relDeltaPtMu);
if( relDeltaPtMu < deltaPtMax ) {
// and matches generated pt
if(verbose!=0)printf("Muon is reconstructed \n ");
// Check if the muon is also isolated: check if an isolated muon is present
// in the event that matches the reconstructed muon in R
if( /*muonsRelIso->at(matchedMuonIdx) <= Selection::muIso()*/ true ){
//.................//.................//
// Currently muons are picked if they are isolated.
// So we don't need to put a cut here.
//.................//.................//
// Muon is isolated
if(verbose!=0)printf("Muon is isolated \n ");
// Reconstruction-efficiency determination 2: Counter for those events
// with generator-level muons inside acceptance where the muon has also
// been reconstructed.
// Isolation-efficiency determination 2: Counter for those events where
// the muon is also isolated.
// hIsoRecoPass->Fill( binMap[utils2::findBin(cntNJetsPt30Eta24,nbtag,HT,template_mht).c_str()] );
hIsoRecoPass->Fill( binMap[utils2::findBin_NoB(evt->nJets(),evt->ht(),evt->mht()).c_str()] );
} // End of muon is isolated
} // End of pt matching
} // End of reconstructed muon
} // End of muon in acceptance
} // end of loop over events
// Compute acceptance
TH1* hAcc = static_cast<TH1*>(hAccPass->Clone("hAcc"));
hAcc->Divide(hAccPass,hAccAll,1,1,"B");// we use B option here because the two histograms are correlated. see TH1 page in the root manual.
// Compute efficiencies
TH1* hEff = static_cast<TH1*>(hIsoRecoPass->Clone("hEff"));
hEff->Divide(hIsoRecoPass,hIsoRecoAll,1,1,"B");
if(verbose!=0){
for(int j=1; j<= totNbins; j++){
printf("hAccAll: %g hAccPass: %g hAcc: %g hIsoRecoAll: %g hIsoRecoPass: %g hEff: %g \n ",hAccAll->GetBinContent(j),hAccPass->GetBinContent(j),hAcc->GetBinContent(j),hIsoRecoAll->GetBinContent(j),hIsoRecoPass->GetBinContent(j),hEff->GetBinContent(j));
}
}
// --- Save the Histograms to File -----------------------------------
sprintf(tempname,"LostLepton/LostLepton2_MuonEfficienciesFrom%s_%s.root",subSampleKey.c_str(),inputnumber.c_str());
TFile outFile(tempname,"RECREATE");
hAcc->Write();
hEff->Write();
hAccAll->Write();
hAccPass->Write();
hIsoRecoAll->Write();
hIsoRecoPass->Write();
outFile.Close();
} // end of main
// === Main Function ===================================================
void general1(int sampleId) {
std::cout << "Analysing the " << sampleLabel(sampleId) << " sample" << std::endl;
// --- Declare the Output Histograms ---------------------------------
TH1* hNJets = new TH1F("hNJets",";N(jets);N(events)",12,0,12);
hNJets->Sumw2();
TH1* hHt = new TH1F("hHt",";H_{T} [GeV]",30,0,3000);
hHt->Sumw2();
hHt->GetXaxis()->SetNdivisions(505);
TH1* hMht = new TH1F("hMht",";#slash{H}_{T} [GeV]",30,0,1500);
hMht->Sumw2();
hMht->GetXaxis()->SetNdivisions(505);
TH1* hMEff = new TH1F("hMEff",";M_{eff} [GeV]",50,0,5000);
hMEff->Sumw2();
hMEff->GetXaxis()->SetNdivisions(505);
std::vector<TH1*> hJetPt(6);
std::vector<TH1*> hJetPhi(6);
std::vector<TH1*> hJetEta(6);
for(unsigned int i = 0; i < hJetEta.size(); ++i) {
TString name = "hJetPt_";
name += i;
TString title = ";p_{T}(jet ";
title += i+1;
title += ") [GeV];N(events)";
hJetPt.at(i) = new TH1F(name,title,30,0,1500);
hJetPt.at(i)->Sumw2();
name = "hJetPhi_";
name += i;
title = ";#phi(jet ";
title += i+1;
title += ");N(events)";
hJetPhi.at(i) = new TH1F(name,title,24,-4,4);
hJetPhi.at(i)->Sumw2();
name = "hJetEta_";
name += i;
title = ";#eta(jet ";
title += i+1;
title += ");N(events)";
hJetEta.at(i) = new TH1F(name,title,25,-5,5);
hJetEta.at(i)->Sumw2();
}
// --- Declare the Variables Read from the Tree ----------------------
// Reco-level jets
int nRecoJets = 0;
float recoJetPt[kRecoJetColSize];
float recoJetPhi[kRecoJetColSize];
float recoJetEta[kRecoJetColSize];
// Number of reco-level muons and electrons
int nRecoMus = 0;
int nRecoEle = 0;
// MC Event weight
float evtWgt = 1.;
// --- Set Up the Tree -----------------------------------------------
// Get the tree from file
TChain* tr = new TChain("AnaTree");
tr->Add("/nfs/dust/test/cmsdas/school61/susy/ntuple/2013-v1/"+fileName(sampleId)+"_0.root");
// Set the branches
tr->SetBranchAddress("NrecoJet",&nRecoJets);
tr->SetBranchAddress("recoJetPt",recoJetPt);
tr->SetBranchAddress("recoJetPhi",recoJetPhi);
tr->SetBranchAddress("recoJetEta",recoJetEta);
tr->SetBranchAddress("NrecoMu",&nRecoMus);
tr->SetBranchAddress("NrecoEle",&nRecoEle);
if( sampleId > 0 ) tr->SetBranchAddress("EvtWgt",&evtWgt);
// --- Process the Events in the Tree --------------------------------
int nEvtsToProcess = tr->GetEntries();
std::cout << "Processing " << nEvtsToProcess << " events" << std::endl;
// Loop over the tree entries
for(int evtIdx = 0; evtIdx < nEvtsToProcess; ++evtIdx) {
if( evtIdx%100000 == 0 ) std::cout<<" Event: " << evtIdx << std::endl;
// Get the variables' values for this event
tr->GetEntry(evtIdx);
if( nRecoJets > kRecoJetColSize ) {
std::cerr << "ERROR: more than " << kRecoJetColSize << " reco jets in event " << evtIdx << std::endl;
exit(-1);
}
// Apply the lepton veto
if( nRecoEle > 0 ) continue;
if( nRecoMus > 0 ) continue;
// Calculate RA2 selection-variables from jets
float selNJet = 0; // Number of jets with pt > 50 GeV and |eta| < 2.5 (HT jets)
float selHt = 0.;
float selMhtX = 0.;
float selMhtY = 0.;
// Loop over reco jets: they are ordered in pt
for(int jetIdx = 0; jetIdx < nRecoJets; ++jetIdx) {
// Calculate NJet and HT
if( recoJetPt[jetIdx] > kHtJetPtMin && TMath::Abs(recoJetEta[jetIdx]) < kHtJetEtaMax ) {
selNJet++;
selHt += recoJetPt[jetIdx];
}
// Calculate MHT components
if( recoJetPt[jetIdx] > kMhtJetPtMin && TMath::Abs(recoJetEta[jetIdx]) < kMhtJetEtaMax ) {
selMhtX -= recoJetPt[jetIdx]*TMath::Cos(recoJetPhi[jetIdx]);
selMhtY -= recoJetPt[jetIdx]*TMath::Sin(recoJetPhi[jetIdx]);
}
} // End of loop over reco jets
float selMht = sqrt( selMhtX*selMhtX + selMhtY*selMhtY );
// Select only events with at least 2 HT jets
if( selNJet < 3 ) continue;
//>>> PLACE OTHER RA2 CUTS HERE
// Event weight in plots
float weight = 1.;
if( sampleId == 1 ) weight = evtWgt; // In case of the flat QCD-MC, reweight to physical spectrum
// Fill histogram
hNJets->Fill(selNJet,weight);
hHt->Fill(selHt,weight);
hMht->Fill(selMht,weight);
hMEff->Fill(selHt+selMht,weight);
for(int i = 0; i < static_cast<int>(hJetPt.size()); ++i) {
if( i == nRecoJets ) break;
hJetPt.at(i)->Fill(recoJetPt[i],weight);
hJetPhi.at(i)->Fill(recoJetPhi[i],weight);
hJetEta.at(i)->Fill(recoJetEta[i],weight);
}
} // End of loop over events
// --- Save the Histograms to File -----------------------------------
TFile outFile("General_"+fileName(sampleId)+".root","RECREATE");
hNJets->Write();
hHt->Write();
hMht->Write();
hMEff->Write();
for(unsigned int i = 0; i < hJetPt.size(); ++i) {
hJetPt[i]->Write();
hJetEta[i]->Write();
hJetPhi[i]->Write();
}
}
void plots() {
gSystem->Load("libEVGEN"); // Needs to be!
AliRunLoader* rl = AliRunLoader::Open("galice.root");
rl->LoadKinematics();
rl->LoadHeader();
// 4pi histograms
TH1* hM = new TH1D("hM", "DIME #rho#rho;M_{4#pi} #(){GeV/#it{c}^{2}}", 100, 1.0, 3.0);
TH1* hPt = new TH1D("hPt", "DIME #rho#rho;p_{T}#(){4#pi} #(){GeV/#it{c}}", 100, 0.0, 3.0);
// pi+- histograms
TH1* hPt1 = new TH1D("hPt1", "DIME #rho#rho;p_{T}#(){#pi^{#pm}} #(){Gev/#it{c}}", 100, 0.0, 3.0);
AliStack* stack = NULL;
TParticle* part = NULL;
TLorentzVector v[4];
TLorentzVector vSum;
// Loop over events
for (Int_t i = 0; i < rl->GetNumberOfEvents(); ++i) {
rl->GetEvent(i);
stack = rl->Stack();
Int_t nPrimary = 0;
// Loop over all particles
for (Int_t j = 0; j < stack->GetNtrack(); ++j) {
part = stack->Particle(j); // Get particle
part->Print(); // Print contents
if (abs(part->GetPdgCode()) == 211 // Is pi+ or pi-
& part->GetStatusCode() == 1 // Is stable final state
& stack->IsPhysicalPrimary(j)) { // Is from generator level
part->Momentum(v[nPrimary]); // Set content of v
++nPrimary;
}
}
if (nPrimary != 4) {
printf("Error: nPrimary=%d != 4 \n", nPrimary);
continue;
}
// 4-vector sum
vSum = v[0] + v[1] + v[2] + v[3];
// Fill 4pi histograms
hM->Fill(vSum.M());
hPt->Fill(vSum.Perp());
// Fill pi+- histograms
for (Int_t k = 0; k < 4; ++k) {
hPt1->Fill(v[k].Perp());
}
printf("\n");
}
// Save plots as pdf
hM->Draw(); c1->SaveAs("plotM.pdf");
hPt->Draw(); c1->SaveAs("plotPt.pdf");
hPt1->Draw(); c1->SaveAs("plotPt1.pdf");
}
void blinding_study()
{
gSystem->CompileMacro("MitGPTree.h");
// First we define MIT Style for the plots.
TStyle *MitStyle = gStyle;
//gStyle = MitStyle;
// Canvas
MitStyle->SetCanvasColor (0);
MitStyle->SetCanvasBorderSize(10);
MitStyle->SetCanvasBorderMode(0);
MitStyle->SetCanvasDefH (700);
MitStyle->SetCanvasDefW (700);
MitStyle->SetCanvasDefX (100);
MitStyle->SetCanvasDefY (100);
// Pads
MitStyle->SetPadColor (0);
MitStyle->SetPadBorderSize (10);
MitStyle->SetPadBorderMode (0);
MitStyle->SetPadBottomMargin(0.13);
MitStyle->SetPadTopMargin (0.04);
MitStyle->SetPadLeftMargin (0.18);
MitStyle->SetPadRightMargin (0.04);
MitStyle->SetPadGridX (0);
MitStyle->SetPadGridY (0);
MitStyle->SetPadTickX (0);
MitStyle->SetPadTickY (0);
// Frames
MitStyle->SetFrameFillStyle ( 0);
MitStyle->SetFrameFillColor ( 0);
MitStyle->SetFrameLineColor ( 1);
MitStyle->SetFrameLineStyle ( 0);
MitStyle->SetFrameLineWidth ( 1);
MitStyle->SetFrameBorderSize(10);
MitStyle->SetFrameBorderMode( 0);
// Histograms
MitStyle->SetHistFillColor(2);
MitStyle->SetHistFillStyle(0);
MitStyle->SetHistLineColor(1);
MitStyle->SetHistLineStyle(0);
MitStyle->SetHistLineWidth(2);
MitStyle->SetNdivisions(505);
// Functions
MitStyle->SetFuncColor(1);
MitStyle->SetFuncStyle(0);
MitStyle->SetFuncWidth(2);
// Various
MitStyle->SetMarkerStyle(20);
MitStyle->SetMarkerColor(kBlack);
MitStyle->SetMarkerSize (1.2);
MitStyle->SetTitleSize (0.055,"X");
MitStyle->SetTitleOffset(1.200,"X");
MitStyle->SetLabelOffset(0.005,"X");
MitStyle->SetLabelSize (0.050,"X");
MitStyle->SetLabelFont (42 ,"X");
MitStyle->SetTickLength (-0.03,"X");
MitStyle->SetStripDecimals(kFALSE);
MitStyle->SetTitleSize (0.055,"Y");
MitStyle->SetTitleOffset(1.800,"Y");
MitStyle->SetLabelOffset(0.010,"Y");
MitStyle->SetLabelSize (0.050,"Y");
MitStyle->SetLabelFont (42 ,"Y");
MitStyle->SetTickLength (-0.03,"Y");
MitStyle->SetTextSize (0.055);
MitStyle->SetTextFont (42);
MitStyle->SetStatFont (42);
MitStyle->SetTitleFont (42);
MitStyle->SetTitleFont (42,"X");
MitStyle->SetTitleFont (42,"Y");
MitStyle->SetOptStat (0);
// Here the style section ends and the macro begins.
string sig_samples[] =
{
"s12-dmmpho-v_m1-v7a",
"s12-dmmpho-av_m1-v7a",
"s12-dmmpho-v_m10-v7a",
"s12-dmmpho-av_m10-v7a",
"s12-dmmpho-v_m100-v7a",
"s12-dmmpho-av_m100-v7a",
"s12-dmmpho-v_m200-v7a",
"s12-dmmpho-av_m200-v7a",
"s12-dmmpho-av_m300-v7a",
"s12-dmmpho-v_m500-v7a",
"s12-dmmpho-av_m500-v7a",
"s12-dmmpho-v_m1000-v7a",
"s12-dmmpho-av_m1000-v7a",
"s12-addmpho-md1_d2-v7a",
"s12-addmpho-md1_d3-v7a",
"s12-addmpho-md1_d4-v7a",
"s12-addmpho-md1_d5-v7a",
"s12-addmpho-md1_d6-v7a",
"s12-addmpho-md2_d2-v7a",
"s12-addmpho-md2_d3-v7a",
"s12-addmpho-md2_d5-v7a",
"s12-addmpho-md2_d6-v7a",
"s12-addmpho-md3_d2-v7a",
"s12-addmpho-md3_d3-v7a",
"s12-addmpho-md3_d4-v7a",
"s12-addmpho-md3_d5-v7a",
"s12-addmpho-md3_d6-v7a"
}
Int_t signal_num=0;
// This macro considers only one signal sample at a time, so the variable signal_num defines
// which signal sample to work on (it is the index of the sample in sig_samples).
double sig_weights[] =
{
4.81E-07,
4.79E-07,
4.80E-07,
4.81E-07,
4.77E-07,
4.26E-07,
4.23E-07,
3.18E-07,
2.19E-07,
2.01E-07,
9.52E-08,
3.00E-08,
8.22E-09,
6.48E-02,
1.73E-01,
6.93E-02,
9.17E-02,
9.63E-01,
5.87E-03,
4.91E-03,
4.37E-03,
4.26E-03,
1.45E-03,
7.93E-04,
5.53E-04,
4.26E-04,
3.24E-04
};
// The signal weights are given by (sigma_MC * lumi)/(N_processed). Background weights are defined similarly below.
string bg_samples[] = {"s12-zgptg130-v7c", "s12-wjets-ptw100-v7a", "s12-wgptg130-v7a", "s12-qcdht100-250-v7a", "s12-qcdht250-500-v7a", "s12-qcdht500-1000-v7a",
"s12-qcdht1000-v7a", "s12-2pibo10_25-v7a", "s12-2pibo25_250-v7a", "s12-2pibo250-v7a", "s12-2pibx10_25-v7a", "s12-2pibx25_250-v7a", "s12-2pibx250-v7a",
"s12-pj50_80-v7a", "s12-pj80_120-v7a", "s12-pj120_170-v7a", "s12-pj170_300-v7a", "s12-pj300_470-v7a", "s12-pj470_800-v7a", "s12-pj800_1400-v7a",
"s12-pj1400_1800-v7a", "s12-pj1800-v7a", "s12-zgllgptg130-v7a", "s12-zgllg-v7a"};
double bg_weights[]=
{
5.28E-03,
1.14E-01,
1.38E-02,
5.63E+03,
2.34E+02,
9.71E+00,
3.09E-01,
9.21E+00,
9.90E-01,
4.21E-04,
1.66E+01,
6.43E-01,
4.91E-05,
3.30E+01,
5.49E+00,
1.09E+00,
3.01E-01,
2.15E-02,
2.10E-03,
7.11E-05,
4.45E-07,
1.88E-08,
3.18E-03,
5.10E-01
};
string sigLine = sig_samples[signal_num];
Double_t sigWeight = sig_weights[signal_num];
TH1* sig_hist = new TH1F("sig_hist", TString("Phi Between Met and Photon for Signal Events [") + TString(sigLine) + TString("]"), 70, 0, 3.5);
TH1* bg_hist = new TH1F("bg_hist", TString("Phi Between Met and Photon for Background Events [") + TString(sigLine) + TString("]"), 70, 0, 3.5);
TH1* signifhist = new TH1F("signifhist", TString(" "), 24, 2, 3.2);
cout<<"The selected signal sample is: "<<TString(sigLine)<<" "<<endl;
TString sigFilename = TString("monoph-2013-July9_") + TString(sigLine) + TString("_noskim.root");
MitGPTree sigEvent;
sigEvent.LoadTree(TString("/scratch/cferko/hist/monoph-2013-July9/merged/")+sigFilename, 0);
sigEvent.InitTree(0);
int nDataSig=sigEvent.tree_->GetEntries();
for (int evt=0; evt<nDataSig; ++evt)
{
sigEvent.tree_->GetEntry(evt);
Double_t pho1Pt = sigEvent.pho1_.Pt();
Double_t jet1Pt = sigEvent.jet1_.Pt();
Double_t met = sigEvent.met_;
Double_t metPhi = sigEvent.metPhi_;
Double_t nphotons = sigEvent.nphotons_;
Double_t ncosmics = sigEvent.ncosmics_;
Double_t phoPassEleVeto = sigEvent.phoPassEleVeto_a1_;
Double_t jet1Pt = sigEvent.jet1_.Pt();
Double_t nlep = sigEvent.nlep_;
Double_t pho1Eta = sigEvent.pho1_.Eta();
Double_t pho1Phi = sigEvent.pho1_.Phi();
Double_t phoIsTrigger = sigEvent.phoIsTrigger_a1_;
Double_t phoLeadTimeSpan = sigEvent.phoLeadTimeSpan_a1_;
Double_t phoCoviEtaiEta = sigEvent.phoCoviEtaiEta_a1_;
Double_t phoCoviPhiiPhi = sigEvent.phoCoviPhiiPhi_a1_;
Double_t phoMipIsHalo = sigEvent.phoMipIsHalo_a1_;
Double_t phoSeedTime = sigEvent.phoSeedTime_a1_;
Double_t deltaPhi = TMath::ACos(TMath::Cos(pho1Phi - metPhi));
if (TMath::Abs(pho1Eta)<1.479 && met>140 && pho1Pt>160 && nphotons>0 && phoPassEleVeto>0 && phoIsTrigger==1 && TMath::Abs(phoLeadTimeSpan) < 8. && phoCoviEtaiEta > 0.001 && phoCoviPhiiPhi > 0.001 && phoMipIsHalo == 0 && phoSeedTime > -1.5 && nlep==0 && ncosmics==0 && jet1Pt<100) sig_hist->Fill(deltaPhi, sigWeight);
}
for (int i=0; i<24; i++)
{
string bgLine = bg_samples[i];
Double_t bgWeight = bg_weights[i];
TString bgFilename = TString("monoph-2013-July9_") + TString(bgLine) + TString("_noskim.root");
MitGPTree bgEvent;
bgEvent.LoadTree(TString("/scratch/cferko/hist/monoph-2013-July9/merged/") + bgFilename, 0);
bgEvent.InitTree(0);
int nDataBg=bgEvent.tree_->GetEntries();
for (int evt=0; evt<nDataBg; ++evt)
{
bgEvent.tree_->GetEntry(evt);
Double_t pho1Pt = bgEvent.pho1_.Pt();
Double_t jet1Pt = bgEvent.jet1_.Pt();
Double_t met = bgEvent.met_;
Double_t metPhi = bgEvent.metPhi_;
Double_t nphotons = bgEvent.nphotons_;
Double_t ncosmics = bgEvent.ncosmics_;
Double_t phoPassEleVeto = bgEvent.phoPassEleVeto_a1_;
Double_t jet1Pt = bgEvent.jet1_.Pt();
Double_t nlep = bgEvent.nlep_;
Double_t pho1Eta = bgEvent.pho1_.Eta();
Double_t pho1Phi = bgEvent.pho1_.Phi();
Double_t phoIsTrigger = bgEvent.phoIsTrigger_a1_;
Double_t phoLeadTimeSpan = bgEvent.phoLeadTimeSpan_a1_;
Double_t phoCoviEtaiEta = bgEvent.phoCoviEtaiEta_a1_;
Double_t phoCoviPhiiPhi = bgEvent.phoCoviPhiiPhi_a1_;
Double_t phoMipIsHalo = bgEvent.phoMipIsHalo_a1_;
Double_t phoSeedTime = bgEvent.phoSeedTime_a1_;
Double_t deltaPhi = TMath::ACos(TMath::Cos(pho1Phi - metPhi));
if (TMath::Abs(pho1Eta)<1.479 && met>140 && pho1Pt>160 && nphotons>0 && phoPassEleVeto>0 && phoIsTrigger==1 && TMath::Abs(phoLeadTimeSpan) < 8. && phoCoviEtaiEta > 0.001 && phoCoviPhiiPhi > 0.001 && phoMipIsHalo == 0 && phoSeedTime > -1.5 && nlep==0 && ncosmics==0 && jet1Pt<100) bg_hist->Fill(deltaPhi, bgWeight);
}
}
Double_t sigTot = sig_hist->Integral();
Double_t bgTot = bg_hist->Integral();
Double_t signifTot = sigTot/TMath::Sqrt(bgTot);
Double_t signifTarget = 0.25*signifTot;
Int_t reduced=0;
// The strange limits in the for loop are a messy hack to get the integral to work out. Since hist->Integral(a,b)
// integrates from BIN a to BIN b (bin numbers instead of values of the x-axis), I choose to work from bin 64
// (an angle cut of 3.2) to bin 40 (an angle cut of 2).
for (int i=64; i>=40; i--)
{
Double_t sigcount = sig_hist->Integral(0, i);
Double_t bgcount = bg_hist->Integral(0, i);
if (bgcount>0)
{
Double_t significance = sigcount/TMath::Sqrt(bgcount);
// cout<<"At a phi cut of "<<sig_hist->GetBinCenter(i)+0.025<<" the significance is "<<significance<<", which is a fraction "<<significance/signifTot<<" of max."<<endl;
if (significance<signifTarget && reduced==0)
{
cout<<"The signal significance is reduced to one-fourth of its uncut value at a phi cut of "<<sig_hist->GetBinCenter(i)+0.025<<endl;
reduced=1;
}
signifhist->Fill(sig_hist->GetBinCenter(i), significance);
}
}
signifhist->SetStats(kFALSE);
signifhist->GetXaxis()->SetTitle("Maximum #Delta#phi");
signifhist->GetYaxis()->SetTitle("Signal Significance");
signifhist->Draw();
c1->Print(TString("Blinding_") + TString(sigLine) + TString(".pdf"));
}
void plot_ZJetBalance( int index, int bin, TH1& responseHistGen,
TH1& responseHistReco, TH1& genJetpt,
TH1& caloJetpt, TH1& recoZpt ) {
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
TChain* t = new TChain("ZJet");
if( useLocalFile == true ) t->Add("analysis_zjet.root");
else t->Add(basename + TString("*.root"));
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
Float_t JetRecoPt[20][4];
Float_t JetCorPt[20][4];
Float_t JetGenPt[20][4];
Float_t JetRecoEta[20][4];
Float_t JetGenEta[20][4];
Float_t JetRecoPhi[20][4];
Float_t JetGenPhi[20][4];
Float_t JetRecoType[20][4];
Float_t Z_Pt;
Float_t Z_Phi;
Float_t Z_Eta;
Float_t Z_PtGen;
Float_t Z_PhiGen;
Float_t ePlusPt;
Float_t eMinusPt;
Float_t ePlusPtGen;
Float_t eMinusPtGen;
Float_t ePlusEta;
Float_t eMinusEta;
Float_t ePlusPhi;
Float_t eMinusPhi;
Float_t mZeeGen;
Float_t mZee;
Float_t ePlus_ecaliso_20;
Float_t ePlus_sc_e;
Float_t eMinus_ecaliso_20;
Float_t eMinus_sc_e;
Float_t ePlus_ptisoatecal_15;
Float_t eMinus_ptisoatecal_15;
t->SetBranchAddress("JetGenPt", JetGenPt);
t->SetBranchAddress("JetGenEta", JetGenEta);
t->SetBranchAddress("JetGenPhi", JetGenPhi);
t->SetBranchAddress("JetCorPt", JetCorPt);
t->SetBranchAddress("JetRecoPt", JetRecoPt);
t->SetBranchAddress("JetRecoEta", JetRecoEta);
t->SetBranchAddress("JetRecoPhi", JetRecoPhi);
t->SetBranchAddress("Z_Pt", &Z_Pt);
t->SetBranchAddress("Z_Phi", &Z_Phi);
t->SetBranchAddress("Z_Eta", &Z_Eta);
t->SetBranchAddress("Z_PtGen", &Z_PtGen);
t->SetBranchAddress("Z_PhiGen", &Z_PhiGen);
t->SetBranchAddress("ePlusPt", &ePlusPt);
t->SetBranchAddress("eMinusPt", &eMinusPt);
t->SetBranchAddress("ePlusPtGen", &ePlusPtGen);
t->SetBranchAddress("eMinusPtGen",&eMinusPtGen);
t->SetBranchAddress("ePlusEta", &ePlusEta);
t->SetBranchAddress("eMinusEta", &eMinusEta);
t->SetBranchAddress("ePlusPhi", &ePlusPhi);
t->SetBranchAddress("eMinusPhi", &eMinusPhi);
t->SetBranchAddress("mZeeGen", &mZeeGen);
t->SetBranchAddress("mZee", &mZee);
t->SetBranchAddress("ePlus_ecaliso_20", &ePlus_ecaliso_20);
t->SetBranchAddress("ePlus_sc_e", &ePlus_sc_e);
t->SetBranchAddress("eMinus_ecaliso_20", &eMinus_ecaliso_20);
t->SetBranchAddress("eMinus_sc_e", &eMinus_sc_e);
t->SetBranchAddress("ePlus_ptisoatecal_15", &ePlus_ptisoatecal_15);
t->SetBranchAddress("eMinus_ptisoatecal_15", &eMinus_ptisoatecal_15);
t->SetBranchStatus("*", 0);
t->SetBranchStatus("JetGenPt", 1);
t->SetBranchStatus("JetGenEta", 1);
t->SetBranchStatus("JetGenPhi", 1);
t->SetBranchStatus("JetRecoPt", 1);
t->SetBranchStatus("JetRecoEta", 1);
t->SetBranchStatus("JetRecoPhi", 1);
t->SetBranchStatus("JetCorPt", 1);
t->SetBranchStatus("JetCorEta", 1);
t->SetBranchStatus("JetCorPhi", 1);
t->SetBranchStatus("Z_Pt", 1);
t->SetBranchStatus("Z_Phi", 1);
t->SetBranchStatus("Z_Eta", 1);
t->SetBranchStatus("Z_PtGen", 1);
t->SetBranchStatus("Z_PhiGen", 1);
t->SetBranchStatus("ePlusPt", 1);
t->SetBranchStatus("eMinusPt", 1);
t->SetBranchStatus("ePlusPtGen", 1);
t->SetBranchStatus("eMinusPtGen", 1);
t->SetBranchStatus("ePlusEta", 1);
t->SetBranchStatus("eMinusEta", 1);
t->SetBranchStatus("ePlusPhi", 1);
t->SetBranchStatus("eMinusPhi", 1);
t->SetBranchStatus("mZeeGen", 1);
t->SetBranchStatus("mZee", 1);
t->SetBranchStatus("ePlus_ecaliso_20", 1);
t->SetBranchStatus("ePlus_sc_e", 1);
t->SetBranchStatus("eMinus_ecaliso_20", 1);
t->SetBranchStatus("eMinus_sc_e", 1);
t->SetBranchStatus("ePlus_ptisoatecal_15", 1);
t->SetBranchStatus("eMinus_ptisoatecal_15", 1);
for (Long64_t entry =0; entry < t->GetEntries(); entry++) {
t->GetEntry(entry);
if(entry%20000==0) std::cout<<"************ Event # "<< entry <<std::endl;
bool isPtCut = (ePlusPt>20.0) && (eMinusPt>20.0) &&
(Z_Pt > GenPt[bin]) && (Z_Pt < GenPt[bin+1]);
bool isEtaCutP = (fabs(ePlusEta)<1.4442) ||
(fabs(ePlusEta)>1.560 && fabs(ePlusEta)<2.5);
bool isEtaCutM = (fabs(eMinusEta)<1.4442) ||
(fabs(eMinusEta)>1.560 && fabs(eMinusEta)<2.5);
bool isECALiso = (ePlus_ecaliso_20 > 0.0) &&
(ePlus_ecaliso_20 < 0.2) && (eMinus_ecaliso_20 > 0.0) &&
(eMinus_ecaliso_20 < 0.2);
bool isTrackiso = (ePlus_ptisoatecal_15 < 0.2) &&
(eMinus_ptisoatecal_15 < 0.2);
if( !(isPtCut && isEtaCutP && isEtaCutM && isECALiso &&
isTrackiso && fabs(mZee-91.2)<2.5) ) continue;
float leadGenJetPt=JetGenPt[index][0];
float secondGenJetPt=JetGenPt[index][0];
int leadRecoIndex=-1, secondRecoIndex=-1;
float leadRecoJetPt = 0.0;
float secondRecoJetPt = 0.0;
leadRecoIndex = 0;
secondRecoIndex = 1;
leadRecoJetPt = JetRecoPt[index][0];
secondRecoJetPt = JetRecoPt[index][1];
// FindLeadIndex(JetRecoCorrectedPt[index], leadRecoIndex[index], secondRecoIndex[index]);
// leadRecoJetPt = JetRecoCorrectedPt[index][leadRecoIndex];
// secondRecoJetPt = JetRecoCorrectedPt[index][secondRecoIndex];
// if(leadRecoIndex==-1) continue;
// ************ test: apply jet pT cut *****************
if( JetRecoPt[index][0] < MINPTCUT ||
JetRecoPt[index][1] < MINPTCUT ) continue;
float leadRecoJetEta = JetRecoEta[index][leadRecoIndex];
double dPhiReco = dPhi(JetRecoPhi[index][leadRecoIndex], Z_Phi);
if( fabs(dPhiReco)<2.94 || fabs(leadRecoJetEta)>1.3 ||
secondRecoJetPt/leadRecoJetPt>0.2 ) continue;
double ptRatioGen = leadGenJetPt/Z_PtGen;
double ptRatioReco = 0.0;
if(usingCorrectedCaloJetPt) ptRatioReco = JetCorPt[index][0]/Z_Pt;
else ptRatioReco = JetRecoPt[index][0]/Z_Pt;
responseHistGen.Fill( ptRatioGen );
responseHistReco.Fill( ptRatioReco );
genJetpt.Fill(leadGenJetPt);
caloJetpt.Fill(leadRecoJetPt);
recoZpt.Fill( Z_Pt );
} // end TTree loop
if(makeplot_ZptBalance==true) {
TString plotname =
Form("ptBalance-allCuts_%d_%d", (int) GenPt[bin],
(int) GenPt[bin+1] );
PlotOnCanvas( responseHistGen, responseHistReco,
plotname);
}
}
void
GetEccenNpart_new(char* xname = "ile")
{
gStyle->SetOptStat(0);
gStyle->SetTitle(0);
char name[100];
TChain* ch = new TChain("t");
int n;
//you need a file list of root ntuple: fxxxx.lis
//
sprintf(name,"f%s.lis",xname);
cout << "open the filelist : " << name << endl;
ifstream fin(name);
string filename;
while(!fin.eof()){
fin >> filename;
if(filename.empty()) continue;
cout << filename << endl;
ch->AddFile(filename.c_str());
}
fin.close();
double b;
int ncoll;
int npart;
int nHitBbc_n, nHitBbc_s;
double qBBC_n, qBBC_s;
double vertex, ecc_std, ecc_rp, ecc_part,e4;
double r_oll,r_geo,r_arith;
ch->SetBranchAddress("b", &b );
ch->SetBranchAddress("vertex", &vertex );
ch->SetBranchAddress("ncoll", &ncoll );
ch->SetBranchAddress("npart", &npart );
ch->SetBranchAddress("ecc_std", &ecc_std );
ch->SetBranchAddress("ecc_rp", &ecc_rp );
ch->SetBranchAddress("ecc_part", &ecc_part );
ch->SetBranchAddress("r_ollitra", &r_oll );
ch->SetBranchAddress("r_geo", &r_geo );
ch->SetBranchAddress("r_arith", &r_arith );
ch->SetBranchAddress("e4", &e4 );
ch->SetBranchAddress("qBBC_n", &qBBC_n );
ch->SetBranchAddress("qBBC_s", &qBBC_s );
ch->SetBranchAddress("nHitBbc_n", &nHitBbc_n);
ch->SetBranchAddress("nHitBbc_s", &nHitBbc_s);
char fname[100];
sprintf(fname,"rootfile/g%s_cent.root",xname);
TFile* fout = new TFile(fname,"recreate");//rootfile to save distributions
TH1* hbbcq = new TH1D("hbbcq","hbbcq",12000,-0.5,2999.5); hbbcq->Sumw2();
TH1* hbbcqall = new TH1D("hbbcqall","hbbcqall",12000,-0.5,2999.5);hbbcqall->Sumw2();
TH1* hbbcqeff = new TH1D("hbbcqeff","hbbcqeff",12000,-0.5,2999.5);hbbcqeff->Sumw2();
n = ch->GetEntries();
cout << "events: "<< n << endl;
//First loop determines the BBC trigger efficiency
//as function of bbcq;
for(int i=0; i<n; i++){
ch->GetEntry(i);
if(nHitBbc_n>=2&&nHitBbc_s>=2){
hbbcq->Fill( (qBBC_n+qBBC_s)/100. );//divide by 100 to fit in 0-3000 range
}
hbbcqall->Fill( (qBBC_n+qBBC_s)/100. );
}
hbbcqeff->Divide(hbbcq,hbbcqall);
efficiency = hbbcq->Integral()/hbbcqall->Integral();
cout << "efficiency : " << efficiency << endl;
//hbin contains the integrated fraction starting from 0 bbc charge, including the BBC trigger efficiency
TH1* hbin = new TH1D("hbin","hbin",hbbcq->GetNbinsX(),-0.5,2999.5);
TH1* hbbcqscale = (TH1*)hbbcq->Clone("hbbcqscale");
hbbcqscale->Scale(1.0/hbbcq->Integral());
for(int i=1; i<=hbbcqscale->GetNbinsX(); i++){
hbin->SetBinContent(i,hbbcqscale->Integral(1,i));
}
//Following two lines defines the array of cuts and average bbc charge
//for centrality percentitle in 5%, 10% and 20% steps
double bbcq5[21],bbcq10[11],bbcq20[6];
double abbcq5[20],abbcq10[10],abbcq20[5];
//calculate the various variables for 5% step
GetCentrality(hbin,20,bbcq5,hbbcq,abbcq5);
cout << endl << endl;
//calculate the various variables for 10% step
GetCentrality(hbin,10,bbcq10,hbbcq,abbcq10);
cout << endl << endl;
//calculate the various variables for 20% step
GetCentrality(hbin,5,bbcq20,hbbcq,abbcq20);
cout << endl << endl;
cout << " Find cuts for all the centralities " << endl << endl;
const int nval=9;//number of variables to fill
char* centname[3] = {"5pStep","10pStep","20pStep"};
char* varname[nval] = {"npart","ncoll","b","standard_ecc","reactionplane_ecc","participant_ecc","R_Ollitraut","R_Geo", "R_arith"};
double vup[nval] = {499.5,2999.5,19.995,1,1,1,4,4,4};
double vlo[nval] = {-0.5,-0.5,-0.005,-1,-1,-1,0,0,0};
int vNb[nval] = {500,3000,2000,200,200,200,400,400,400};
//initialize the histograms which are used to fill the distribution of variables for each centrality
TH1* hvar[3][nval][20];
for(int i=0; i<3; i++){
int NC = 0;
if(i==0) NC = 20;
else if(i==1) NC = 10;
else if(i==2) NC = 5;
for(int ivar=0; ivar<nval; ivar++){
for(int icen=0; icen<NC; icen++){
sprintf(name,"hvar_%s_%s_cent%d",centname[i],varname[ivar],icen);
hvar[i][ivar][icen] = new TH1D(name,name,vNb[ivar],vlo[ivar],vup[ivar]);
}
}
}
double qbbcsum;
for(int i=0; i<n; i++){
if(i%1000000==0) cout << i << endl;
ch->GetEntry(i);
if(!(nHitBbc_n>=2&&nHitBbc_s>=2)) continue;//BBC trigger condition
qbbcsum = (qBBC_n+qBBC_s)/100.;
int centbin5 = FindBin(20,bbcq5,qbbcsum);
int centbin10 = FindBin(10,bbcq10,qbbcsum);
int centbin20 = FindBin(5,bbcq20,qbbcsum);
if(centbin5==-1) continue;
if(centbin10==-1) continue;
if(centbin20==-1) continue;
//find the weight according to the corresponding average efficiency.
double weight = hbbcqeff->GetBinContent(hbbcqeff->FindBin(qbbcsum));
//5 percent step
//
hvar[0][0][centbin5]->Fill(npart,weight);
hvar[0][1][centbin5]->Fill(ncoll,weight);
hvar[0][2][centbin5]->Fill(b,weight);
hvar[0][3][centbin5]->Fill(ecc_std,weight);
hvar[0][4][centbin5]->Fill(ecc_rp,weight);
hvar[0][5][centbin5]->Fill(ecc_part,weight);
hvar[0][6][centbin5]->Fill(r_oll,weight);
hvar[0][7][centbin5]->Fill(r_geo,weight);
hvar[0][8][centbin5]->Fill(r_arith,weight);
//10 percent step
//
hvar[1][0][centbin10]->Fill(npart,weight);
hvar[1][1][centbin10]->Fill(ncoll,weight);
hvar[1][2][centbin10]->Fill(b,weight);
hvar[1][3][centbin10]->Fill(ecc_std,weight);
hvar[1][4][centbin10]->Fill(ecc_rp,weight);
hvar[1][5][centbin10]->Fill(ecc_part,weight);
hvar[1][6][centbin10]->Fill(r_oll,weight);
hvar[1][7][centbin10]->Fill(r_geo,weight);
hvar[1][8][centbin10]->Fill(r_arith,weight);
//20 percent step
//
hvar[2][0][centbin20]->Fill(npart,weight);
hvar[2][1][centbin20]->Fill(ncoll,weight);
hvar[2][2][centbin20]->Fill(b,weight);
hvar[2][3][centbin20]->Fill(ecc_std,weight);
hvar[2][4][centbin20]->Fill(ecc_rp,weight);
hvar[2][5][centbin20]->Fill(ecc_part,weight);
hvar[2][6][centbin20]->Fill(r_oll,weight);
hvar[2][7][centbin20]->Fill(r_geo,weight);
hvar[2][8][centbin20]->Fill(r_arith,weight);
}
//get mean and RMS values for the variables
float var[3][nval+1][20];
float rms[3][nval+1][20];
for(int i=0; i<3; i++){
int NC = 0;
if(i==0) NC = 20;
else if(i==1) NC = 10;
else if(i==2) NC = 5;
for(int icen=0; icen<NC; icen++){
for(int ivar=0; ivar<nval; ivar++){
var[i][ivar][icen] = hvar[i][ivar][icen]->GetMean();
rms[i][ivar][icen] = hvar[i][ivar][icen]->GetRMS();
}
var[i][nval][icen] = var[i][1][icen]/sigmann;
rms[i][nval][icen] = rms[i][1][icen]/sigmann;
}
}
//save to file
for(int ivar=0; ivar<4; ivar++){
for(int icen=0; icen<16; icen++){
cout<<var[0][ivar][icen]<<",";
}
cout<<var[2][ivar][4]<<",";
cout<<endl;
}
cout.precision(4);
sprintf(name,"5pstepresults/t%s.txt",xname);
ofstream f5(name);
cout << " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl;
for(int icen=0; icen<19; icen++){
for(int ivar=0; ivar<7; ivar++){
f5 << var[0][ivar][icen] << " ";
}
f5 << var[0][nval][icen] << " ";
f5 <<endl<< " (";
/* for(int ivar=0; ivar<7; ivar++){
f5 << rms[0][ivar][icen] << " ";
}
f5 << rms[0][nval][icen] << " ";
f5 << ")"<< endl;
*/
cout << icen*5 << "-" << icen*5+5;
for(int ivar=0; ivar<7; ivar++){
cout <<" & " <<var[0][ivar][icen] ;
}
cout <<" & " <<var[0][nval][icen] ;
cout <<"\\\\"<<endl;
for(int ivar=0; ivar<7; ivar++){
if(ivar==0)cout <<" & ("<<rms[0][ivar][icen];
else cout <<" & "<<rms[0][ivar][icen];
}
cout <<" & "<<rms[0][nval][icen];
cout << ")\\\\\\hline" << endl;
// printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n",
// var[0][0][icen],var[0][1][icen],var[0][2][icen],var[0][3][icen],var[0][4][icen],var[0][5][icen],var[0][6][icen]);
//printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n",
// rms[0][0][icen],rms[0][1][icen],rms[0][2][icen],rms[0][3][icen],rms[0][4][icen],rms[0][5][icen],rms[0][6][icen]);
}
f5.close();
cout << endl << endl;
sprintf(name,"10pstepresults/t%s.txt",xname);
ofstream f10(name);
cout <<endl<< " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl;
for(int icen=0; icen<10; icen++){
for(int ivar=0; ivar<7; ivar++){
f10 << var[1][ivar][icen] << " ";
}
f10 << var[1][nval][icen] << " ";
f10 <<endl<<" (";
/*for(int ivar=0; ivar<7; ivar++){
f10 << rms[1][ivar][icen] << " ";
}
f10 << rms[1][nval][icen] << " ";
f10 << ")" << endl;
*/
cout << icen*10 << "-" << icen*10+10;
for(int ivar=0; ivar<7; ivar++){
cout <<" & " <<var[1][ivar][icen] ;
}
cout <<" & " <<var[1][nval][icen] ;
cout <<"\\\\"<<endl;
for(int ivar=0; ivar<7; ivar++){
if(ivar==0)cout <<" & ("<<rms[1][ivar][icen];
else cout <<" & "<<rms[1][ivar][icen];
}
cout <<" & "<<rms[1][nval][icen];
cout << ")\\\\\\hline" << endl;
//printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n",
// var[1][0][icen],var[1][1][icen],var[1][2][icen],var[1][3][icen],var[1][4][icen],var[1][5][icen],var[1][6][icen]);
//printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n",
// rms[1][0][icen],rms[1][1][icen],rms[1][2][icen],rms[1][3][icen],rms[1][4][icen],rms[1][5][icen],rms[1][6][icen]);
}
f10.close();
cout << endl << endl;
sprintf(name,"20pstepresults/t%s.txt",xname);
ofstream f20(name);
cout <<endl<< " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl;
for(int icen=0; icen<5; icen++){
for(int ivar=0; ivar<7; ivar++){
f20 << var[2][ivar][icen] << " ";
}
f20 << var[2][nval][icen] << " ";
f20 << endl<< " (";
/*for(int ivar=0; ivar<7; ivar++){
f20 << rms[2][ivar][icen] << " ";
}
f20 << rms[2][nval][icen] << " ";
f20 << ")"<< endl;
*/
cout << icen*20 << "-" << icen*20+20;
for(int ivar=0; ivar<7; ivar++){
cout <<" & " <<var[2][ivar][icen] ;
}
cout <<" & " <<var[2][nval][icen] ;
cout <<"\\\\"<<endl;
for(int ivar=0; ivar<7; ivar++){
if(ivar==0)cout <<" & ("<<rms[2][ivar][icen];
else cout <<" & "<<rms[2][ivar][icen];
}
cout <<" & "<<rms[2][nval][icen];
cout << ")\\\\\\hline" << endl;
//printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n",
// var[2][0][icen],var[2][1][icen],var[2][2][icen],var[2][3][icen],var[2][4][icen],var[2][5][icen],var[2][6][icen]);
//printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n",
// rms[2][0][icen],rms[2][1][icen],rms[2][2][icen],rms[2][3][icen],rms[2][4][icen],rms[2][5][icen],rms[2][6][icen]);
}
f20.close();
fout->Write();
fout->Close();
return;
}
void simul(int Nevents = 200000, double Twist_width = 0.04, double Asy_wdith = 0.06){
char name[200];
TFile *OutFile=new TFile("Simu3.root","recreate");
OutFile->cd();
TRandom3 ran;
//20-25% events have ~1092 multiplicity
const int MEAN_MULT =1092,SIGMA_MULT=86 ;//Mean and rms of total multiplicity (det0+det1+det2)
int min=MEAN_MULT-5*SIGMA_MULT;
int max=MEAN_MULT+5*SIGMA_MULT;
if(min<0) min=0;
TF1 *Mult_func=new TF1("mult_func","exp(-(x-[0])*(x-[0])/(2*[1]*[1]))",min,max);
Mult_func->SetParameter(0,MEAN_MULT );
Mult_func->SetParameter(1,SIGMA_MULT);
//
TFile* fout = new TFile("toyout.root","recreate");
TF1* v2_func=new TF1("v2_func","x*exp(-(x*x+[0]*[0])/(2*[1]))*TMath::BesselI0(x*[0]/[1])",0,0.40);
v2_func->SetParameter(0,9.13212e-02);
v2_func->SetParameter(1,1.20361e-03);
//
Float_t v2 =0 ;//true v2 at eta=0, this will be the refer
Float_t Psi2 =0 ;//true Psi2 at eta=0
float vncut[] = {0.00, 0.04, 0.06,0.1, 0.12, 0.14, 0.15};
TProfile* hpr_qn[2];
for (int iq=0; iq<2; iq++) {
sprintf(name, "hpr_qn_%d", iq); hpr_qn[iq] = new TProfile(name,"", 7, 0, 7);
}
TH1* hebin = new TH1D("hebin","", 7, 0, 7);
TH1* hmul = new TH1D("hmul","", 2000, 0, 2000);
TH1* hmuleta = new TH1D("hmuleta","", NETA, -ETAMAX, ETAMAX);
TH1* hmulphi = new TH1D("hmulphi","", 120 , -PI, PI);
TH1* hv2 = new TH1D("hv2","",1000, 0, 0.5);
TH1* hv4 = new TH1D("hv4","",1000, 0, 0.5);
double q2[2];
double q4[2];
float qw;
for(int iev=0; iev<Nevents; iev++){
if(iev%10000==0) cout<<iev<<endl;
v2 = v2_func->GetRandom();//0.05;//True v2
Psi2 = ((ran.Rndm()-0.5)*2*PI)/2.0; //True Psi_2 angle
// int ntrk = 1092;
int ntrk = 8000;
qw = 0;
std::memset(q2, 0, sizeof(q2) );
std::memset(q4, 0, sizeof(q4) );
for(int itrk =0; itrk<ntrk; itrk++){
float phi = (ran.Rndm()-0.5)*2*PI;//random angle for the particle
float trk_vn = v2 ;
float trk_psin = Psi2;
phi =add_flow(phi ,trk_vn, trk_psin);
q2[0] += cos(2*phi); q2[1] += sin(2*phi);
q4[0] += cos(4*phi); q4[1] += sin(4*phi);
qw++;
}//end of itrk
double mv2 = sqrt(q2[0]*q2[0] + q2[1]*q2[1]);
double mv4 = sqrt(q4[0]*q4[0] + q4[1]*q4[1]);
mv2 = mv2/qw;
mv4 = mv4/qw;
int ebin = 0;
for (int j=0; j<7; j++) {
if(mv2>= vncut[7-1-j]){
ebin = 7-1-j;
break;
}
}
hv2->Fill( mv2 );
hv4->Fill( mv4 );
hpr_qn[0]->Fill(ebin, mv2);
hpr_qn[1]->Fill(ebin, mv4);
hebin->Fill( ebin );
}//end of iev
float xx[7] = {0};
float xxE[7] = {0};
float yy[7] = {0};
float yyE[7] = {0};
for (int j=0; j<7; j++) {
xx[j] =hpr_qn[0]->GetBinContent( j+1); xxE[j] =hpr_qn[0]->GetBinError( j+1);
yy[j] =hpr_qn[1]->GetBinContent( j+1); yyE[j] =hpr_qn[1]->GetBinError( j+1);
}
TGraphErrors* gr = new TGraphErrors(7,xx, yy, xxE, yyE);
hv2->Write();
hv4->Write();
gr->SetName("gr");
gr->Write();
hebin->Write();
hpr_qn[0]->Write();
hpr_qn[1]->Write();
v2_func->Write();
cout<<"Task ends"<<endl;
}//end of sim
void plotMarkovChainMonitorTree()
{
std::string inputFilePath = "/data1/veelken/tmp/svFitStudies/";
std::vector<std::string> eventsToProcess;
eventsToProcess.push_back("1:102093:40804761");
//eventsToProcess.push_back("1:3369:1346645");
//eventsToProcess.push_back("1:89621:35819785");
//eventsToProcess.push_back("1:79157:31638382");
std::string genNtupleFileName = "/data1/veelken/tmp/svFitStudies/testNSVfitTrackLikelihoods3_ntuple_Higgs_mutau_125_2012Nov30.root";
gROOT->SetBatch(true);
for ( std::vector<std::string>::const_iterator eventToProcess = eventsToProcess.begin();
eventToProcess != eventsToProcess.end(); ++eventToProcess ) {
std::cout << "processing " << (*eventToProcess) << std::endl;
TObjArray* run_ls_event = TString(eventToProcess->data()).Tokenize(":");
assert(run_ls_event);
if ( run_ls_event->GetEntries() != 3 ) {
std::cerr << "Failed to parse " << (*eventToProcess) << " !!" << std::endl;
assert(0);
}
int run = convertToInt(*run_ls_event, 0);
int ls = convertToInt(*run_ls_event, 1);
int event = convertToInt(*run_ls_event, 2);
std::string inputFileName = Form(
"%s/nSVfitProducerByIntegration2W%sMaxGenVertex_run%i_ls%i_ev%i_mc.root",
inputFilePath.data(), "decayKinePlusMEt", run, ls, event);
TFile* inputFile = new TFile(inputFileName.data());
assert(inputFile);
std::string treeName = "monitorTree";
TTree* monitorTree = dynamic_cast<TTree*>(inputFile->Get(treeName.data()));
assert(monitorTree);
int numEntries = monitorTree->GetEntries();
TH2* histogramDensity_vs_X1_and_X2 = new TH2D("histogramDensity_vs_X1_and_X2", "histogramDensity_vs_X1_and_X2", 100, 0., 1., 100, 0., 1.);
TH2* histogramMass_vs_X1_and_X2 = new TH2D("histogramMass_vs_X1_and_X2", "histogramMass_vs_X1_and_X2", 100, 0., 1., 100, 0., 1.);
TH2* histogramDensity_vs_decayDist1_and_phi1 = new TH2D("histogramDensity_vs_decayDist1_and_phi1", "histogramDensity_vs_decayDist1_and_phi1", 200, -0.2, +0.2, 180, -TMath::Pi(), +TMath::Pi());
TH2* histogramDensity_vs_X1_and_phi1 = new TH2D("histogramDensity_vs_X1_and_phi1", "histogramDensity_vs_X1_and_phi1", 100, 0., 1., 180, -TMath::Pi(), +TMath::Pi());
TH2* histogramDensity_vs_decayDist2_and_phi2 = new TH2D("histogramDensity_vs_decayDist2_and_phi2", "histogramDensity_vs_decayDist2_and_phi2", 200, -0.2, +0.2, 180, -TMath::Pi(), +TMath::Pi());
TH2* histogramDensity_vs_X2_and_phi2 = new TH2D("histogramDensity_vs_X2_and_phi2", "histogramDensity_vs_X2_and_phi2", 100, 0., 1., 180, -TMath::Pi(), +TMath::Pi());
TH1* histogramDiTauPtDistribution = new TH1D("histogramDiTauPtDistribution", "histogramDiTauPtDistribution", 250, 0., 250.);
TH1* histogramDiTauEtaDistribution = new TH1D("histogramDiTauEtaDistribution", "histogramDiTauEtaDistribution", 198, -9.9, +9.9);
TH1* histogramDiTauPhiDistribution = new TH1D("histogramDiTauPhiDistribution", "histogramDiTauPhiDistribution", 360, -TMath::Pi(), +TMath::Pi());
TH1* histogramDiTauMassDistribution = new TH1D("histogramDiTauMassDistribution", "histogramDiTauMassDistribution", 250, 0., 250.);
TH1* histogramSVfitMass_unweighted = bookMassHistogram("histogramSVfitMass_unweighted");
TH1* histogramSVfitMass_gjAngle_labGt0_00025_unweighted = bookMassHistogram("histogramSVfitMass_gjAngle_labGt0_00025_unweighted");
TH1* histogramSVfitMass_gjAngle_labLt0_00025_unweighted = bookMassHistogram("histogramSVfitMass_gjAngle_labLt0_00025_unweighted");
TH1* histogramSVfitMass_weighted = bookMassHistogram("histogramSVfitMass_weighted");
TH1* histogramSVfitMass_gjAngle_labGt0_00025_weighted = bookMassHistogram("histogramSVfitMass_gjAngle_labGt0_00025_weighted");
TH1* histogramSVfitMass_gjAngle_labLt0_00025_weighted = bookMassHistogram("histogramSVfitMass_gjAngle_labLt0_00025_weighted");
TH1* histogramLeg1PtDistribution = new TH1D("histogramLeg1PtDistribution", "histogramLeg1PtDistribution", 250, 0., 250.);
TH1* histogramLeg1EtaDistribution = new TH1D("histogramLeg1EtaDistribution", "histogramLeg1EtaDistribution", 198, -9.9, +9.9);
TH1* histogramLeg1PhiDistribution = new TH1D("histogramLeg1PhiDistribution", "histogramLeg1PhiDistribution", 360, -TMath::Pi(), +TMath::Pi());
TH1* histogramLeg1dEtaDistribution = new TH1D("histogramLeg1dEtaDistribution", "histogramLeg1dPhiDistribution", 400, -0.05, +0.05);
TH1* histogramLeg1dPhiDistribution = new TH1D("histogramLeg1dPhiDistribution", "histogramLeg1dEtaDistribution", 400, -0.05, +0.05);
TH2* histogramLeg1dPhi_vs_dEtaDistribution = new TH2D("histogramLeg1dPhi_vs_dEtaDistribution", "histogramLeg1dPhi_vs_dEtaDistribution", 400, -0.05, +0.05, 400, -0.05, +0.05);
TH1* histogramLeg2PtDistribution = new TH1D("histogramLeg2PtDistribution", "histogramLeg1PtDistribution", 250, 0., 250.);
TH1* histogramLeg2EtaDistribution = new TH1D("histogramLeg2EtaDistribution", "histogramLeg2EtaDistribution", 198, -9.9, +9.9);
TH1* histogramLeg2PhiDistribution = new TH1D("histogramLeg2PhiDistribution", "histogramLeg2PhiDistribution", 360, -TMath::Pi(), +TMath::Pi());
TH1* histogramLeg2dEtaDistribution = new TH1D("histogramLeg2dEtaDistribution", "histogramLeg2dPhiDistribution", 400, -0.05, +0.05);
TH1* histogramLeg2dPhiDistribution = new TH1D("histogramLeg2dPhiDistribution", "histogramLeg2dEtaDistribution", 400, -0.05, +0.05);
TH2* histogramLeg2dPhi_vs_dEtaDistribution = new TH2D("histogramLeg2dPhi_vs_dEtaDistribution", "histogramLeg2dPhi_vs_dEtaDistribution", 400, -0.05, +0.05, 400, -0.05, +0.05);
TH1* histogramMoveDistribution = new TH1D("histogramMoveDistribution", "histogramMoveDistribution", 1000, 0., monitorTree->GetEntries());
TGraph* graphEvolution_X1 = new TGraph(numEntries);
TGraph* graphEvolution_phiLab1 = new TGraph(numEntries);
TGraph* graphEvolution_decayDist1 = new TGraph(numEntries);
TGraph* graphEvolution_X2 = new TGraph(numEntries);
TGraph* graphEvolution_phiLab2 = new TGraph(numEntries);
TGraph* graphEvolution_decayDist2 = new TGraph(numEntries);
Float_t X1, phiLab1, decayDistance1, X2, phiLab2, decayDistance2;
monitorTree->SetBranchAddress("x0", &X1);
monitorTree->SetBranchAddress("x1", &phiLab1);
//monitorTree->SetBranchAddress("x2", &decayDistance1);
//monitorTree->SetBranchAddress("x3", &X2);
//monitorTree->SetBranchAddress("x4", &phiLab2);
//monitorTree->SetBranchAddress("x5", &decayDistance2);
//monitorTree->SetBranchAddress("x0", &X1);
//monitorTree->SetBranchAddress("x1", &phiLab1);
monitorTree->SetBranchAddress("x2", &X2);
monitorTree->SetBranchAddress("x3", &phiLab2);
//monitorTree->SetBranchAddress("x1", &X2);
//monitorTree->SetBranchAddress("x0", &phiLab1);
//monitorTree->SetBranchAddress("x1", &phiLab2);
Float_t diTauPt, diTauEta, diTauPhi, diTauMass;
monitorTree->SetBranchAddress("APt", &diTauPt);
monitorTree->SetBranchAddress("AEta", &diTauEta);
monitorTree->SetBranchAddress("APhi", &diTauPhi);
monitorTree->SetBranchAddress("AMass", &diTauMass);
Float_t leg1Pt, leg1Eta, leg1Phi, leg1VisPt, leg1VisEta, leg1VisPhi;
monitorTree->SetBranchAddress("A_leg1Pt", &leg1Pt);
monitorTree->SetBranchAddress("A_leg1Eta", &leg1Eta);
monitorTree->SetBranchAddress("A_leg1Phi", &leg1Phi);
monitorTree->SetBranchAddress("A_leg1VisPt", &leg1VisPt);
monitorTree->SetBranchAddress("A_leg1VisEta", &leg1VisEta);
monitorTree->SetBranchAddress("A_leg1VisPhi", &leg1VisPhi);
Float_t leg2Pt, leg2Eta, leg2Phi, leg2VisPt, leg2VisEta, leg2VisPhi;
monitorTree->SetBranchAddress("A_leg2Pt", &leg2Pt);
monitorTree->SetBranchAddress("A_leg2Eta", &leg2Eta);
monitorTree->SetBranchAddress("A_leg2Phi", &leg2Phi);
monitorTree->SetBranchAddress("A_leg2VisPt", &leg2VisPt);
monitorTree->SetBranchAddress("A_leg2VisEta", &leg2VisEta);
monitorTree->SetBranchAddress("A_leg2VisPhi", &leg2VisPhi);
Int_t move;
monitorTree->SetBranchAddress("move", &move);
TF1* pdfWeight_vs_eta_m90 = new TF1("pdfWeight_vs_eta", "[0] + x*([1] + x*([2] + x*([3] + x*([4] + x*([5] + x*[6])))))", -2., +2.);
pdfWeight_vs_eta_m90->SetParameter(0, 0.173744);
pdfWeight_vs_eta_m90->SetParameter(1, 1.00115e-18);
pdfWeight_vs_eta_m90->SetParameter(2, -0.0370055);
pdfWeight_vs_eta_m90->SetParameter(3, 3.40875e-17);
pdfWeight_vs_eta_m90->SetParameter(4, -0.014232);
pdfWeight_vs_eta_m90->SetParameter(5, -1.07345e-17);
pdfWeight_vs_eta_m90->SetParameter(6, 0.00320732);
for ( int iEntry = 0; iEntry < numEntries; ++iEntry ) {
monitorTree->GetEntry(iEntry);
if ( (iEntry % 100000) == 0 )
//if ( TMath::Abs(leg1Eta - leg1VisEta) < 0.000250 && TMath::Abs(leg1Phi - leg1VisPhi) < 0.000250 )
std::cout << "entry #" << iEntry << ":"
<< " X1 = " << X1 << ", phiLab1 = " << phiLab1 << ", decayDistance1 = " << decayDistance1 << ","
<< " X2 = " << X2 << ", phiLab2 = " << phiLab2 << ", decayDistance2 = " << decayDistance2 << ", Mass = " << diTauMass << std::endl;
//if ( !(leg2Eta > 0.0485 && leg2Eta < 0.0495) ) continue;
//if ( !(phiLab1 > 1. && phiLab1 < 2.) ) continue;
//if ( !(phiLab1 > -2. && phiLab1 < -1.) ) continue;
histogramDensity_vs_X1_and_X2->Fill(X1, X2);
histogramMass_vs_X1_and_X2->Fill(X1, X2, diTauMass);
histogramDensity_vs_decayDist1_and_phi1->Fill(decayDistance1, phiLab1);
histogramDensity_vs_X1_and_phi1->Fill(X1, phiLab1);
histogramDensity_vs_decayDist2_and_phi2->Fill(decayDistance2, phiLab2);
histogramDensity_vs_X2_and_phi2->Fill(X2, phiLab2);
histogramDiTauPtDistribution->Fill(diTauPt);
histogramDiTauEtaDistribution->Fill(diTauEta);
histogramDiTauPhiDistribution->Fill(diTauPhi);
histogramDiTauMassDistribution->Fill(diTauMass);
double gjAngle_lab = TMath::Sqrt(square(leg1Eta - leg1VisEta) + square(leg1Phi - leg1VisPhi));
double jacobiFactor = 2.*TMath::Pi()*gjAngle_lab;
//double weight = jacobiFactor;
//double weight = pdfWeight_vs_eta_m90->Eval(diTauEta);
double weight = compDeltaFunctionJacobiFactor(X1)*compDeltaFunctionJacobiFactor(X2);
//double weight = compDeltaFunctionJacobiFactor(X1)*compDeltaFunctionJacobiFactor(X2)*(X1*X2);
std::cout << "eta = " << diTauEta << ": weight = " << weight << std::endl;
histogramSVfitMass_unweighted->Fill(diTauMass);
histogramSVfitMass_weighted->Fill(diTauMass, weight);
if ( gjAngle_lab > 0.00025 ) {
histogramSVfitMass_gjAngle_labGt0_00025_unweighted->Fill(diTauMass);
histogramSVfitMass_gjAngle_labGt0_00025_weighted->Fill(diTauMass, weight);
} else {
histogramSVfitMass_gjAngle_labLt0_00025_unweighted->Fill(diTauMass);
histogramSVfitMass_gjAngle_labLt0_00025_weighted->Fill(diTauMass, weight);
}
histogramLeg1PtDistribution->Fill(leg1Pt);
histogramLeg1EtaDistribution->Fill(leg1Eta);
histogramLeg1PhiDistribution->Fill(leg1Phi);
histogramLeg1dEtaDistribution->Fill(leg1Eta - leg1VisEta);
histogramLeg1dPhiDistribution->Fill(leg1Phi - leg1VisPhi);
histogramLeg1dPhi_vs_dEtaDistribution->Fill(leg1Eta - leg1VisEta, leg1Phi - leg1VisPhi);
//std::cout << "leg1Eta = " << leg1Eta << ", leg1VisEta = " << leg1VisEta << " --> dEta = " << (leg1Eta - leg1VisEta) << ";"
// << " leg1Phi = " << leg1Phi << ", leg1VisPhi = " << leg1VisPhi << " --> dPhi = " << (leg1Phi - leg1VisPhi) << std::endl;
histogramLeg2PtDistribution->Fill(leg2Pt);
histogramLeg2EtaDistribution->Fill(leg2Eta);
histogramLeg2PhiDistribution->Fill(leg2Phi);
histogramLeg2dEtaDistribution->Fill(leg2Eta - leg2VisEta);
histogramLeg2dPhiDistribution->Fill(leg2Phi - leg2VisPhi);
histogramLeg2dPhi_vs_dEtaDistribution->Fill(leg2Eta - leg2VisEta, leg2Phi - leg2VisPhi);
//std::cout << "leg2Eta = " << leg2Eta << ", leg2VisEta = " << leg2VisEta << " --> dEta = " << (leg2Eta - leg2VisEta) << ";"
// << " leg2Phi = " << leg2Phi << ", leg2VisPhi = " << leg2VisPhi << " --> dPhi = " << (leg2Phi - leg2VisPhi) << std::endl;
histogramMoveDistribution->Fill(move);
graphEvolution_X1->SetPoint(iEntry, move, X1);
graphEvolution_phiLab1->SetPoint(iEntry, move, phiLab1);
graphEvolution_decayDist1->SetPoint(iEntry, move, decayDistance1);
graphEvolution_X2->SetPoint(iEntry, move, X2);
graphEvolution_phiLab2->SetPoint(iEntry, move, phiLab2);
graphEvolution_decayDist2->SetPoint(iEntry, move, decayDistance2);
}
histogramMass_vs_X1_and_X2->Divide(histogramDensity_vs_X1_and_X2);
Float_t genX1, genX2;
Float_t genDiTauPt, genDiTauEta, genDiTauPhi, genDiTauMass;
//getGen(genNtupleFileName, run, ls, event, genX1, genX2, genDiTauPt, genDiTauEta, genDiTauPhi, genDiTauMass);
/*
showHistogram2d(
histogramDensity_vs_X1_and_X2, "X_{1}", "X_{2}", kNormByNegLogMax, 0., 2., &genX1, &genX2,
Form("plots/plotMarkovChainMonitorTree_density_vs_X1andX2_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram2d(
histogramMass_vs_X1_and_X2, "X_{1}", "X_{2}", kNormByValue, 0., 250., 0, 0,
Form("plots/plotMarkovChainMonitorTree_mass_vs_X1andX2_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram2d(
histogramDensity_vs_decayDist1_and_phi1, "D^{decay}_{1}", "#phi^{lab}_{1}", kNormByNegLogMax, 0., 2., 0, 0,
Form("plots/plotMarkovChainMonitorTree_density_vs_decayDist1andPhi1_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram2d(
histogramDensity_vs_X1_and_phi1, "X_{1}", "#phi^{lab}_{1}", kNormByNegLogMax, 0., 2., 0, 0,
Form("plots/plotMarkovChainMonitorTree_density_vs_X1andPhi1_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram2d(
histogramDensity_vs_decayDist2_and_phi2, "D^{decay}_{2}", "#phi^{lab}_{2}", kNormByNegLogMax, 0., 2., 0, 0,
Form("plots/plotMarkovChainMonitorTree_density_vs_decayDist2andPhi2_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram2d(
histogramDensity_vs_X2_and_phi2, "X_{2}", "#phi^{lab}_{2}", kNormByNegLogMax, 0., 2., 0, 0,
Form("plots/plotMarkovChainMonitorTree_density_vs_X2andPhi2_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramDiTauPtDistribution, "P_{T}^{#tau#tau}", &genDiTauPt,
Form("plots/plotMarkovChainMonitorTree_diTauPtDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramDiTauEtaDistribution, "#eta_{#tau#tau}", &genDiTauEta,
Form("plots/plotMarkovChainMonitorTree_diTauEtaDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramDiTauPhiDistribution, "#phi_{#tau#tau}", &genDiTauPhi,
Form("plots/plotMarkovChainMonitorTree_diTauPhiDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramDiTauMassDistribution, "M_{#tau#tau}", &genDiTauMass,
Form("plots/plotMarkovChainMonitorTree_diTauMassDistribution_run%i_ls%i_ev%i.root", run, ls, event));
*/
divideByBinWidth(histogramSVfitMass_unweighted);
std::cout << "SVfit mass (unweighted):" << std::endl;
printMaximum(histogramSVfitMass_unweighted);
showHistogram1d(
histogramSVfitMass_unweighted, "M_{#tau#tau}", &genDiTauMass,
Form("plots/plotMarkovChainMonitorTree_svFitMass_unweighted_run%i_ls%i_ev%i.root", run, ls, event));
divideByBinWidth(histogramSVfitMass_gjAngle_labGt0_00025_unweighted);
showHistogram1d(
histogramSVfitMass_gjAngle_labGt0_00025_unweighted, "M_{#tau#tau}", &genDiTauMass,
Form("plots/plotMarkovChainMonitorTree_svFitMass_gjAngle_labGt0_00025_unweighted_run%i_ls%i_ev%i.root", run, ls, event));
divideByBinWidth(histogramSVfitMass_gjAngle_labLt0_00025_unweighted);
showHistogram1d(
histogramSVfitMass_gjAngle_labLt0_00025_unweighted, "M_{#tau#tau}", &genDiTauMass,
Form("plots/plotMarkovChainMonitorTree_svFitMass_gjAngle_labLt0_00025_unweighted_run%i_ls%i_ev%i.root", run, ls, event));
divideByBinWidth(histogramSVfitMass_weighted);
std::cout << "SVfit mass (weighted by Jacobi factor):" << std::endl;
printMaximum(histogramSVfitMass_weighted);
showHistogram1d(
histogramSVfitMass_weighted, "M_{#tau#tau}", &genDiTauMass,
Form("plots/plotMarkovChainMonitorTree_svFitMass_weighted_run%i_ls%i_ev%i.root", run, ls, event));
divideByBinWidth(histogramSVfitMass_gjAngle_labGt0_00025_weighted);
showHistogram1d(
histogramSVfitMass_gjAngle_labGt0_00025_weighted, "M_{#tau#tau}", &genDiTauMass,
Form("plots/plotMarkovChainMonitorTree_svFitMass_gjAngle_labGt0_00025_weighted_run%i_ls%i_ev%i.root", run, ls, event));
divideByBinWidth(histogramSVfitMass_gjAngle_labLt0_00025_weighted);
showHistogram1d(
histogramSVfitMass_gjAngle_labLt0_00025_weighted, "M_{#tau#tau}", &genDiTauMass,
Form("plots/plotMarkovChainMonitorTree_svFitMass_gjAngle_labLt0_00025_weighted_run%i_ls%i_ev%i.root", run, ls, event));
/*
showHistogram1d(
histogramLeg1PtDistribution, "P_{T}^{1}", 0,
Form("plots/plotMarkovChainMonitorTree_leg1PtDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramLeg1EtaDistribution, "#eta_{1}", 0,
Form("plots/plotMarkovChainMonitorTree_leg1EtaDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramLeg1PhiDistribution, "#phi_{1}", 0,
Form("plots/plotMarkovChainMonitorTree_leg1PhiDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramLeg1dEtaDistribution, "#eta_{1} - #eta_{vis}", 0,
Form("plots/plotMarkovChainMonitorTree_leg1dEta_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramLeg1dPhiDistribution, "#phi_{1} - #phi_{vis}", 0,
Form("plots/plotMarkovChainMonitorTree_leg1dPhi_run%i_ls%i_ev%i.root", run, ls, event));
*/
showHistogram2d(
histogramLeg1dPhi_vs_dEtaDistribution, "#eta_{1} - #eta_{vis}", "#phi_{1} - #phi_{vis}", kNormByNegLogMax, 0., 2., 0, 0,
Form("plots/plotMarkovChainMonitorTree_leg1dPhi_vs_dEta_run%i_ls%i_ev%i.root", run, ls, event));
/*
showHistogram1d(
histogramLeg2PtDistribution, "P_{T}^{2}", 0,
Form("plots/plotMarkovChainMonitorTree_leg2PtDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramLeg2EtaDistribution, "#eta_{2}", 0,
Form("plots/plotMarkovChainMonitorTree_leg2EtaDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramLeg2PhiDistribution, "#phi_{2}", 0,
Form("plots/plotMarkovChainMonitorTree_leg2PhiDistribution_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramLeg2dEtaDistribution, "#eta_{2} - #eta_{vis}", 0,
Form("plots/plotMarkovChainMonitorTree_leg2dEta_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramLeg2dPhiDistribution, "#phi_{2} - #phi_{vis}", 0,
Form("plots/plotMarkovChainMonitorTree_leg2dPhi_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram2d(
histogramLeg2dPhi_vs_dEtaDistribution, "#eta_{2} - #eta_{vis}", "#phi_{2} - #phi_{vis}", kNormByNegLogMax, 0., 2., 0, 0,
Form("plots/plotMarkovChainMonitorTree_leg2dPhi_vs_dEta_run%i_ls%i_ev%i.root", run, ls, event));
showHistogram1d(
histogramMoveDistribution, "Move", 0,
Form("plots/plotMarkovChainMonitorTree_moveDistribution_run%i_ls%i_ev%i.root", run, ls, event));
*/
/*
showGraph(
graphEvolution_X1, "Move", &genX1, 0., 1., "X_{1}",
Form("plots/plotMarkovChainMonitorTree_evolution_X1_run%i_ls%i_ev%i.root", run, ls, event));
showGraph(
graphEvolution_phiLab1, "Move", 0, -TMath::Pi(), +TMath::Pi(), "#phi^{lab}_{1}",
Form("plots/plotMarkovChainMonitorTree_evolution_phiLab1_run%i_ls%i_ev%i.root", run, ls, event));
showGraph(
graphEvolution_decayDist1, "Move", 0, -1., +1., "D^{decay}_{1}",
Form("plots/plotMarkovChainMonitorTree_evolution_decayDist1_run%i_ls%i_ev%i.root", run, ls, event));
showGraph(
graphEvolution_X2, "Move", &genX2, 0., 1., "X_{2}",
Form("plots/plotMarkovChainMonitorTree_evolution_X2_run%i_ls%i_ev%i.root", run, ls, event));
showGraph(
graphEvolution_phiLab2, "Move", 0, -TMath::Pi(), +TMath::Pi(), "#phi^{lab}_{2}",
Form("plots/plotMarkovChainMonitorTree_evolution_phiLab2_run%i_ls%i_ev%i.root", run, ls, event));
showGraph(
graphEvolution_decayDist2, "Move", 0, -1., +1., "D^{decay}_{2}",
Form("plots/plotMarkovChainMonitorTree_evolution_decayDist2_run%i_ls%i_ev%i.root", run, ls, event));
*/
delete histogramDensity_vs_X1_and_X2;
delete histogramMass_vs_X1_and_X2;
delete histogramDensity_vs_decayDist1_and_phi1;
delete histogramDensity_vs_X1_and_phi1;
delete histogramDensity_vs_decayDist2_and_phi2;
delete histogramDensity_vs_X2_and_phi2;
delete histogramDiTauPtDistribution;
delete histogramDiTauEtaDistribution;
delete histogramDiTauPhiDistribution;
delete histogramDiTauMassDistribution;
delete histogramSVfitMass_unweighted;
delete histogramSVfitMass_gjAngle_labGt0_00025_unweighted;
delete histogramSVfitMass_gjAngle_labLt0_00025_unweighted;
delete histogramSVfitMass_weighted;
delete histogramSVfitMass_gjAngle_labGt0_00025_weighted;
delete histogramSVfitMass_gjAngle_labLt0_00025_weighted;
delete histogramLeg1PtDistribution;
delete histogramLeg1EtaDistribution;
delete histogramLeg1PhiDistribution;
delete histogramLeg1dPhi_vs_dEtaDistribution;
delete histogramLeg2PtDistribution;
delete histogramLeg2EtaDistribution;
delete histogramLeg2PhiDistribution;
delete histogramLeg2dPhi_vs_dEtaDistribution;
delete histogramMoveDistribution;
delete graphEvolution_X1;
delete graphEvolution_phiLab1;
delete graphEvolution_decayDist1;
delete graphEvolution_X2;
delete graphEvolution_phiLab2;
delete graphEvolution_decayDist2;
delete inputFile;
}
}
static PyObject *
fill_hist_with_ndarray(PyObject *self, PyObject *args, PyObject* keywords) {
using namespace std;
PyObject *hist_ = NULL;
PyObject *array_ = NULL;
PyObject *weights_ = NULL;
PyArrayObject *array = NULL;
PyArrayObject *weights = NULL;
TH1* hist = NULL;
TH2* hist2d = NULL;
TH3* hist3d = NULL;
unsigned int dim = 1;
unsigned int array_depth = 1;
unsigned int i, n, k;
char *array_data;
char *weights_data = NULL;
npy_intp array_stride_n;
npy_intp array_stride_k = 1;
npy_intp weights_stride = 1;
static const char* keywordslist[] = {
"hist",
"array",
"weights",
NULL};
if(!PyArg_ParseTupleAndKeywords(
args, keywords, "OO|O",
const_cast<char **>(keywordslist),
&hist_, &array_, &weights_)) {
return NULL;
}
if(!PyCObject_Check(hist_)) {
PyErr_SetString(PyExc_TypeError,"Unable to convert hist to PyCObject");
return NULL;
}
//this is not safe so be sure to know what you are doing type check in python first
//this is a c++ limitation because void* have no vtable so dynamic cast doesn't work
hist = static_cast<TH1*>(PyCObject_AsVoidPtr(hist_));
if (hist == NULL) {
PyErr_SetString(PyExc_TypeError,"Unable to convert hist to TH1*");
return NULL;
}
dim = hist->GetDimension();
if (dim == 2) {
hist2d = static_cast<TH2*>(PyCObject_AsVoidPtr(hist_));
if (hist2d == NULL) {
PyErr_SetString(PyExc_TypeError,"Unable to convert hist to TH2*");
return NULL;
}
} else if (dim == 3) {
hist3d = static_cast<TH3*>(PyCObject_AsVoidPtr(hist_));
if (hist3d == NULL) {
PyErr_SetString(PyExc_TypeError,"Unable to convert hist to TH3*");
return NULL;
}
} else if (dim > 3) {
PyErr_SetString(PyExc_ValueError,"dim must not be greater than 3");
return NULL;
}
if (dim > 1)
array_depth = 2;
array = (PyArrayObject *) PyArray_ContiguousFromAny(
array_, PyArray_DOUBLE, array_depth, array_depth);
if (array == NULL) {
PyErr_SetString(PyExc_TypeError,
"Unable to convert object to array");
return NULL;
}
if (dim > 1) {
k = array->dimensions[1];
if (k != dim) {
PyErr_SetString(PyExc_ValueError,
"length of the second dimension must equal the dimension of the histogram");
Py_DECREF(array);
return NULL;
}
array_stride_k = array->strides[1];
}
n = array->dimensions[0];
array_stride_n = array->strides[0];
array_data = array->data;
if (weights_) {
weights = (PyArrayObject *) PyArray_ContiguousFromAny(
weights_, PyArray_DOUBLE, 1, 1);
if (weights == NULL) {
PyErr_SetString(PyExc_TypeError,
"Unable to convert object to array");
Py_DECREF(array);
return NULL;
}
if (n != weights->dimensions[0]) {
PyErr_SetString(PyExc_ValueError,
"array and weights must have the same length");
Py_DECREF(weights);
Py_DECREF(array);
return NULL;
}
weights_data = weights->data;
weights_stride = weights->strides[0];
}
if (dim == 1) {
// weighted fill
if (weights) {
for (i = 0; i < n; ++i) {
hist->Fill(
*(double *)(array_data + i * array_stride_n),
*(double *)(weights_data + i * weights_stride));
}
} else {
// unweighted fill
for (i = 0; i < n; ++i) {
hist->Fill(*(double *)(array_data + i * array_stride_n));
}
}
} else if (dim == 2) {
// weighted fill
if (weights) {
for (i = 0; i < n; ++i) {
hist2d->Fill(
*(double *)(array_data + i * array_stride_n),
*(double *)(array_data + i * array_stride_n + array_stride_k),
*(double *)(weights_data + i * weights_stride));
}
} else {
// unweighted fill
for (i = 0; i < n; ++i) {
hist2d->Fill(
*(double *)(array_data + i * array_stride_n),
*(double *)(array_data + i * array_stride_n + array_stride_k));
}
}
} else if (dim == 3) {
// weighted fill
if (weights) {
for (i = 0; i < n; ++i) {
hist3d->Fill(
*(double *)(array_data + i * array_stride_n),
*(double *)(array_data + i * array_stride_n + array_stride_k),
*(double *)(array_data + i * array_stride_n + 2 * array_stride_k),
*(double *)(weights_data + i * weights_stride));
}
} else {
// unweighted fill
for (i = 0; i < n; ++i) {
hist3d->Fill(
*(double *)(array_data + i * array_stride_n),
*(double *)(array_data + i * array_stride_n + array_stride_k),
*(double *)(array_data + i * array_stride_n + 2 * array_stride_k));
}
}
}
if (weights)
Py_DECREF(weights);
Py_DECREF(array);
Py_RETURN_NONE;
}
//_____________________________
void muIDCutsOptim::Loop()
{
// In a ROOT session, you can do:
// root> .L muIDCutsOptim.C
// root> muIDCutsOptim t
// root> t.GetEntry(12); // Fill t data members with entry number 12
// root> t.Show(); // Show values of entry 12
// root> t.Show(16); // Read and show values of entry 16
// root> t.Loop(); // Loop on all entries
//
// This is the loop skeleton where:
// jentry is the global entry number in the chain
// ientry is the entry number in the current Tree
// Note that the argument to GetEntry must be:
// jentry for TChain::GetEntry
// ientry for TTree::GetEntry and TBranch::GetEntry
//
if (fChain == 0) return;
//===== Definition of file type, particle and if we want the high purity cut included in the soft muon ID cuts
const char* fileType = "MC";
const char* particle = "JPsi";
fIspp = kFALSE;
fIncludeHighPurity = kFALSE;
//=====
Long64_t nentries(0);
if ( !strcmp(fileType,"MC") ) nentries = fChain->GetEntries();
else nentries = 1500000;
std::cout << "# Events = " << nentries << std::endl;
//===== Definition of some cuts
Double_t leMinvSig = 3.0; // Signal range
Double_t ueMinvSig = 3.2;
Double_t leMinvBkg1 = 2.7; // Bkg 1 range (sideband)
Double_t ueMinvBkg1 = 2.9;
Double_t leMinvBkg2 = 3.3; // Bkg 1 range (sideband)
Double_t ueMinvBkg2 = 3.5;
Double_t Ptmin = 3.0; // Pt cut (6.5) (3.0)
Double_t Ptmax = 6.5; // (12.0) (6.5)
Double_t Ymin = 2.0; // Y cut (0.0) (2.0)
Double_t Ymax = 2.4; // (2.4) (2.4)
//=====
//===== Definition of MuID variables and binning
const int nvar = 19;
const char* varname[19] = {"isGoodMuon", "highPurity", "TrkMuArb", "TMOneStaTight", "nPixValHits",
"nMuValHits", "nTrkHits", "normChi2_inner", "normChi2_global", "nPixWMea",
"nTrkWMea", "StationsMatched", "dxy", "dxyErr", "dz",
"dzErr", "ptErr_inner", "ptErr_global","VtxProb"};
const int nbins[19] = {2, 2, 2, 2, 11,
56, 36, 100, 100, 6,
19, 7, 100, 100, 100,
100, 100, 100, 200};
const double lowedge[19] = {0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0};
const double hiedge[19] = {2, 2, 2, 2, 11,
56, 36, 10, 50, 6,
19, 7, 2, 0.25, 20,
5, 0.15, 0.15, 1.};
//=====
SelectBranches(nvar,varname); // Activates only desired branches (General and MuID ones in this case)
//====== Create histograms and arrays to store them ========
TObjArray* aDistr = new TObjArray();
TObjArray* aSig = new TObjArray();
TObjArray* aBkg = new TObjArray();
TObjArray* aSigC = new TObjArray();
TObjArray* aBkgC = new TObjArray();
TObjArray* aGlob = new TObjArray();
TObjArray* aMinvCuts = new TObjArray();
TObjArray* aSigSoftMuCutsButOne = new TObjArray();
TObjArray* aBkgSoftMuCutsButOne = new TObjArray();
TObjArray* aSigSoftMuCuts = new TObjArray();
TObjArray* aBkgSoftMuCuts = new TObjArray();
map<TString, TH1F*> hists_sig, hists_bkg, hists_sig_distr, hists_bkg_distr, hists_distr, hists_sig_distr_CutTest, hists_bkg_distr_CutTest, hists_sig_SofMu, hists_bkg_SofMu;
TString sHPName("");
if ( fIncludeHighPurity ) sHPName += "highPurity"; // This is for the histograms creation
TObjArray* dummyA(0x0);
TString partType("");
for (int i=0; i<nvar; i++)
{
// Single cuts histos
hists_sig[Form("%s",varname[i])] = new TH1F(Form("h%s_sig",varname[i]),Form("Signal di-#mu %s cut distribution",varname[i]),nbins[i],lowedge[i],hiedge[i]);
hists_bkg[Form("%s",varname[i])] = new TH1F(Form("h%s_bkg",varname[i]),Form("Background di-#mu %s cut distribution",varname[i]),nbins[i],lowedge[i],hiedge[i]);
// Variable distributions histos
hists_sig_distr[Form("%s",varname[i])] = new TH1F(Form("h%s_sig_distr",varname[i]),Form("Signal single-#mu %s distribution",varname[i]),nbins[i],lowedge[i],hiedge[i]);
hists_bkg_distr[Form("%s",varname[i])] = new TH1F(Form("h%s_bkg_distr",varname[i]),Form("Background single-#mu %s distribution",varname[i]),nbins[i],lowedge[i],hiedge[i]);
partType.Clear();
if ( !strcmp(varname[i],"VtxProb") ) partType += "di-#mu";
else partType += "di-#mu";
hists_distr[Form("%s",varname[i])] = new TH1F(Form("h%s_distr",varname[i]),Form("Sig+Bkg %s %s distribution",partType.Data(),varname[i]),nbins[i],lowedge[i],hiedge[i]);
dummyA = new TObjArray();
dummyA->SetName(Form("mInv_%s",varname[i]));
aMinvCuts->Add(dummyA);
if ( !strcmp(varname[i],"isGoodMuon") || !strcmp(varname[i],sHPName.Data()) || !strcmp(varname[i],"nPixWMea") || !strcmp(varname[i],"nTrkWMea") || !strcmp(varname[i],"dxy") || !strcmp(varname[i],"dz") )
{
// Histos for all the soft muon cuts applied but the one on the histo
hists_sig_distr_CutTest[Form("%s",varname[i])] = new TH1F(Form("hSoftMuNoCut_%s_sig",varname[i]),Form("Signal single-#mu %s distribution (w/ rest of soft MuID cuts)",varname[i]),nbins[i],lowedge[i],hiedge[i]);
hists_bkg_distr_CutTest[Form("%s",varname[i])] = new TH1F(Form("hSoftMuNoCut_%s_bkg",varname[i]),Form("Background single-#mu %s distribution (w/ rest of soft MuID cuts)",varname[i]),nbins[i],lowedge[i],hiedge[i]);
hists_sig_SofMu[Form("%s",varname[i])] = new TH1F(Form("hSoftMuCut_%s_sig",varname[i]),Form("Signal di-#mu %s cut distribution (w/ all Soft MuID cuts except %s)",varname[i],varname[i]),nbins[i],lowedge[i],hiedge[i]);
hists_bkg_SofMu[Form("%s",varname[i])] = new TH1F(Form("hSoftMuCut_%s_bkg",varname[i]),Form("Background di-#mu %s cut distribution (w/ all Soft MuID cuts except %s)",varname[i],varname[i]),nbins[i],lowedge[i],hiedge[i]);
}
else
{
// Histos for all the soft muon cuts applied
hists_sig_distr_CutTest[Form("%s",varname[i])] = new TH1F(Form("hSoftMuFull_%s_sig",varname[i]),Form("Signal %s %s distribution (w/ all Soft MuID cuts)",partType.Data(),varname[i]),nbins[i],lowedge[i],hiedge[i]);
hists_bkg_distr_CutTest[Form("%s",varname[i])] = new TH1F(Form("hSoftMuFull_%s_bkg",varname[i]),Form("Signal %s %s distribution (w/ all Soft MuID cuts)",partType.Data(),varname[i]),nbins[i],lowedge[i],hiedge[i]);
hists_sig_SofMu[Form("%s",varname[i])] = new TH1F(Form("hSoftMuCut_%s_sig",varname[i]),Form("Signal di-#mu %s cut distribution (w/ all Soft MuID cuts)",varname[i]),nbins[i],lowedge[i],hiedge[i]);
hists_bkg_SofMu[Form("%s",varname[i])] = new TH1F(Form("hSoftMuCut_%s_bkg",varname[i]),Form("Background di-#mu %s cut distribution (w/ all Soft MuID cuts)",varname[i]),nbins[i],lowedge[i],hiedge[i]);
}
}
// Histos for global distributions
TH1* hpt = new TH1D("hPtSig",Form("Dimuon p_{T} distribution (%2.1f < m_{#mu^{+}#mu^{-}} < %2.1f)",leMinvSig,ueMinvSig),300,0.0,15.0);
TH1* hptw = new TH1D("hPtSigW",Form("Dimuon p_{T} distribution weighted (%2.1f < m_{#mu^{+}#mu^{-}} < %2.1f)",leMinvSig,ueMinvSig),300,0.0,15.0);
TH1* hMinvw = new TH1D("hmInv","Dimuon m_{inv} distribution",600,0.,15.0);
TH1* hRapw = new TH1D("hRap","Dimuon rapidity distribution",180,-4.5,4.5);
TH1* hPtw = new TH1D("hPt","Dimuon p_{T} distribution",300,0.0,15.0);
TH1* hCent = new TH1D("hCent","Centrality distribution",200,0.,100);
TH1* hCentw = new TH1D("hCentw","Weighted centrality distribution",200,0.,100);
//======================
TLorentzVector *tlvmupl(0x0);
TLorentzVector *tlvmumi(0x0);
TLorentzVector *tlvqq(0x0);
Long64_t nbytes = 0, nb = 0;
//*************** Event loop
for (Long64_t jentry=0; jentry<nentries;jentry++)
{
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
if ( jentry % 1000 == 0 ) std::cout << jentry << "/" << nentries << std::endl;
Double_t weight = fChain->GetWeight()*GetNColl(Centrality); // This is the weight for the Pt and centrality. The weight stored in the chain is filterEficiency/nentries
//Fill centrality histo
hCentw->Fill(Centrality/2.,weight);
hCent->Fill(Centrality/2.);
//*************** Loop on reco dimuons
// for (int i=0; i<Reco_QQ_size; i++)
// {
Int_t i(0);
Bool_t kQQfound(kFALSE);
while ( i < Reco_QQ_size && !kQQfound ) // This is just to take only the first dimuon passing the basic conditions, to not double count single muons
{
if ( !isTriggerSelected(i) || Reco_QQ_sign[i]!=0 )
{
i++;
continue; // Checks if the event is selected by the trigger
}
// if (Reco_QQ_sign[i]!=0) continue;
tlvmupl = (TLorentzVector*) Reco_QQ_mupl_4mom->At(i);
tlvmumi = (TLorentzVector*) Reco_QQ_mumi_4mom->At(i);
if (!IsAccept(tlvmupl->Pt(), tlvmupl->Eta()) || !IsAccept(tlvmumi->Pt(), tlvmumi->Eta()))
{
i++;
continue; // Basic single muon kinematic cuts
}
tlvqq = (TLorentzVector*) Reco_QQ_4mom->At(i);
Double_t mass = tlvqq->M();
Double_t QQPt = tlvqq->Pt();
Double_t QQY = TMath::Abs(tlvqq->Rapidity());
if ( QQPt < Ptmin || QQPt > Ptmax || QQY < Ymin || QQY > Ymax )
{
i++;
continue; // The simulation is restricted to pt in [Ptmin,Ptmax], so this rejects background dmuons outside the range
}
bool issig = (mass>leMinvSig && mass<ueMinvSig);
bool isbkg = ((mass>leMinvBkg1 && mass<ueMinvBkg1) || (mass>leMinvBkg2 && mass<ueMinvBkg2));
if ( !issig && ! isbkg )
{
i++;
continue; // We keep only dimuons in the sidebands and signal ranges
}
kQQfound = kTRUE; // If at this point the dimuon has passed the basic conditions we keep only this dimuon from the event
const double varValP[19] = {Reco_QQ_mupl_isGoodMuon[i],Reco_QQ_mupl_highPurity[i],Reco_QQ_mupl_TrkMuArb[i],Reco_QQ_mupl_TMOneStaTight[i],Reco_QQ_mupl_nPixValHits[i],Reco_QQ_mupl_nMuValHits[i],Reco_QQ_mupl_nTrkHits[i],Reco_QQ_mupl_normChi2_inner[i],Reco_QQ_mupl_normChi2_global[i],Reco_QQ_mupl_nPixWMea[i],Reco_QQ_mupl_nTrkWMea[i],Reco_QQ_mupl_StationsMatched[i],Reco_QQ_mupl_dxy[i],Reco_QQ_mupl_dxyErr[i],Reco_QQ_mupl_dz[i],Reco_QQ_mupl_dzErr[i],Reco_QQ_mupl_ptErr_inner[i],Reco_QQ_mupl_ptErr_global[i],Reco_QQ_VtxProb[i]};
const double varValM[19] = {Reco_QQ_mumi_isGoodMuon[i],Reco_QQ_mumi_highPurity[i],Reco_QQ_mumi_TrkMuArb[i],Reco_QQ_mumi_TMOneStaTight[i],Reco_QQ_mumi_nPixValHits[i],Reco_QQ_mumi_nMuValHits[i],Reco_QQ_mumi_nTrkHits[i],Reco_QQ_mumi_normChi2_inner[i],Reco_QQ_mumi_normChi2_global[i],Reco_QQ_mumi_nPixWMea[i],Reco_QQ_mumi_nTrkWMea[i],Reco_QQ_mumi_StationsMatched[i],Reco_QQ_mumi_dxy[i],Reco_QQ_mumi_dxyErr[i],Reco_QQ_mumi_dz[i],Reco_QQ_mumi_dzErr[i],Reco_QQ_mumi_ptErr_inner[i],Reco_QQ_mumi_ptErr_global[i],0.}; //Reco_QQ_VtxProb set to 0. since it is a dimuon variable
//**************************************************
//*************** Fill histos **********************
//**************************************************
//===== General distributions
hMinvw->Fill(mass,weight);
hRapw->Fill(tlvqq->Rapidity(),weight);
hPtw->Fill(QQPt,weight);
if (issig)
{
hpt->Fill(QQPt);
hptw->Fill(QQPt,weight);
}
//=====
//===== MuID distributions
for (int ihist=0; ihist<nvar; ihist++)
{
Bool_t isQQVar = kFALSE;
if ( !strcmp(varname[ihist],"VtxProb") ) isQQVar = kTRUE; // Just to avoid filling the histos twice if testing a variable corresponding to a dimuon
hists_distr[varname[ihist]]->Fill(varValP[ihist],weight); // Signal+ Background variable distribution
if ( !isQQVar ) hists_distr[varname[ihist]]->Fill(varValM[ihist],weight);
if (issig)
{
hists_sig_distr[varname[ihist]]->Fill(varValP[ihist],weight); // Signal variable distribution
if ( !isQQVar ) hists_sig_distr[varname[ihist]]->Fill(varValM[ihist],weight);
}
if (isbkg)
{
hists_bkg_distr[varname[ihist]]->Fill(varValP[ihist],weight); // Background variable distribution
if ( !isQQVar ) hists_bkg_distr[varname[ihist]]->Fill(varValM[ihist],weight);
}
////_______ Soft muons cut testing MuID distributions
Int_t nTest = whichMuIDVar(varname[ihist]); // If the variable is not on the soft muon cuts the full cut is applied
if (isSoftMuon(varValP,nTest))
{
if (issig) hists_sig_distr_CutTest[varname[ihist]]->Fill(varValP[ihist],weight); // Variable distribution with the rest of soft MuID cuts applied (all the soft muon cuts if the variable does't belong to the soft cut)
if (isbkg) hists_bkg_distr_CutTest[varname[ihist]]->Fill(varValP[ihist],weight);
}
if ( !isQQVar && isSoftMuon(varValM,nTest) )
{
if (issig) hists_sig_distr_CutTest[varname[ihist]]->Fill(varValM[ihist],weight);
if (isbkg) hists_bkg_distr_CutTest[varname[ihist]]->Fill(varValM[ihist],weight);
}
////_______
dummyA = static_cast<TObjArray*>(aMinvCuts->FindObject(Form("mInv_%s",varname[ihist])));
TH1* dummyH(0x0);
Double_t nBins = hists_sig[varname[ihist]]->GetNbinsX();
for ( Int_t j=1 ; j<=nBins ; j++)
{
//// Cuts on MuID variables
Double_t cutVal = hists_sig[varname[ihist]]->GetBinLowEdge(j);
if (Cut(varname[ihist],i,cutVal))
{
if (issig) hists_sig[varname[ihist]]->Fill(hists_sig[varname[ihist]]->GetBinCenter(j),weight); // Variable cut distribution
if (isbkg) hists_bkg[varname[ihist]]->Fill(hists_bkg[varname[ihist]]->GetBinCenter(j),weight);
if ( !(dummyH = static_cast<TH1*>(dummyA->FindObject(Form("mInv_%s_Cut%2.4f",varname[ihist],cutVal)))) ) // Creates the minv histogram and store in array (only once)
{
dummyH = new TH1D(Form("mInv_%s_Cut%2.4f",varname[ihist],cutVal),Form("Dimuon m_{inv} distribution (cut on %s: %2.4f)",varname[ihist],cutVal),600,0.,15.0);
dummyA->Add(dummyH);
}
dummyH->Fill(mass,weight); // Invariant mass histo for each variable cut
if ( isSoftMuon(varValP,nTest) && isSoftMuon(varValM,nTest) ) // If the variable is not in the soft MuID cut, the full soft cut is applied and the variable cut distribution is filled
{
if (issig) hists_sig_SofMu[varname[ihist]]->Fill(hists_sig[varname[ihist]]->GetBinCenter(j),weight);
if (isbkg) hists_bkg_SofMu[varname[ihist]]->Fill(hists_bkg[varname[ihist]]->GetBinCenter(j),weight);
}
}
}
}
//=======
i++;
}
}
//====== Save histos ======
TFile *f = new TFile(Form("histos_%s_%s_%s_Pt%2.1f_%2.1f_Y%2.1f_%2.1f.root",fileType,particle,fIncludeHighPurity ? "HPincl" : "NoHPincl",Ptmin,Ptmax,Ymin,Ymax),"RECREATE");
for (int i=0; i<nvar; i++)
{
aSigC->Add(hists_sig[varname[i]]);
aBkgC->Add(hists_bkg[varname[i]]);
aSig->Add(hists_sig_distr[varname[i]]);
aBkg->Add(hists_bkg_distr[varname[i]]);
aDistr->Add(hists_distr[varname[i]]);
aSigSoftMuCutsButOne->Add(hists_sig_distr_CutTest[varname[i]]);
aBkgSoftMuCutsButOne->Add(hists_bkg_distr_CutTest[varname[i]]);
aSigSoftMuCuts->Add(hists_sig_SofMu[varname[i]]);
aBkgSoftMuCuts->Add(hists_bkg_SofMu[varname[i]]);
}
aSigC->Write("SigSingleCut", TObject::kOverwrite | TObject::kSingleKey);
aBkgC->Write("BkgSingleCut", TObject::kOverwrite | TObject::kSingleKey);
aSig->Write("SigDistr", TObject::kOverwrite | TObject::kSingleKey);
aBkg->Write("BkgDistr", TObject::kOverwrite | TObject::kSingleKey);
aDistr->Write("Distr", TObject::kOverwrite | TObject::kSingleKey);
aSigSoftMuCutsButOne->Write("SigDistrSoftMuCutButOne", TObject::kOverwrite | TObject::kSingleKey);
aBkgSoftMuCutsButOne->Write("BkgDistrSoftMuCutButOne", TObject::kOverwrite | TObject::kSingleKey);
aSigSoftMuCuts->Write("SigSoftMuCut", TObject::kOverwrite | TObject::kSingleKey);
aBkgSoftMuCuts->Write("BkgSoftMuCut", TObject::kOverwrite | TObject::kSingleKey);
aGlob->Add(hMinvw);
aGlob->Add(hRapw);
aGlob->Add(hPtw);
aGlob->Add(hpt);
aGlob->Add(hptw);
aGlob->Add(hCent);
aGlob->Add(hCentw);
aGlob->Write("Global", TObject::kOverwrite | TObject::kSingleKey);
aMinvCuts->Write("MinvWCuts", TObject::kOverwrite | TObject::kSingleKey);
f->Close();
//=========
}
void testsl() {
gSystem->Load("libStarLight");
gSystem->Load("libAliStarLight");
TStarLight* sl = new TStarLight("starlight generator", "title", "");
sl->SetParameter("baseFileName = slight #suite of output files will be saved with this base name");
sl->SetParameter("BEAM_1_Z = 82 #Z of projectile");
sl->SetParameter("BEAM_1_A = 208 #A of projectile");
sl->SetParameter("BEAM_2_Z = 82 #Z of target");
sl->SetParameter("BEAM_2_A = 208 #A of target");
sl->SetParameter("BEAM_1_GAMMA = 1470.0 #Gamma of the colliding ion 1");
sl->SetParameter("BEAM_2_GAMMA = 1470.0 #Gamma of the colliding ion 2");
sl->SetParameter("W_MAX = -1 #Max value of w");
sl->SetParameter("W_MIN = -1 #Min value of w");
sl->SetParameter("W_N_BINS = 50 #Bins i w");
sl->SetParameter("RAP_MAX = 9. #max y");
sl->SetParameter("RAP_N_BINS = 200 #Bins i y");
sl->SetParameter("CUT_PT = 0 #Cut in pT? 0 = (no, 1 = yes)");
sl->SetParameter("PT_MIN = 1.0 #Minimum pT in GeV");
sl->SetParameter("PT_MAX = 3.0 #Maximum pT in GeV");
sl->SetParameter("CUT_ETA = 0 #Cut in pseudorapidity? (0 = no, 1 = yes)");
sl->SetParameter("ETA_MIN = -10 #Minimum pseudorapidity");
sl->SetParameter("ETA_MAX = 10 #Maximum pseudorapidity");
sl->SetParameter("PROD_MODE = 2 #gg or gP switch (1 = 2-photon, 2 = coherent vector meson (narrow), 3 = coherent vector meson (wide), 4 = incoherent vector meson)");
sl->SetParameter("N_EVENTS = 1000 #Number of events");
sl->SetParameter("PROD_PID = 443013 #Channel of interest; this is j/psi --> mu+ mu-");
sl->SetParameter("RND_SEED = 5574533 #Random number seed");
sl->SetParameter("BREAKUP_MODE = 5 #Controls the nuclear breakup; a 5 here makes no requirement on the breakup of the ions");
sl->SetParameter("INTERFERENCE = 0 #Interference (0 = off, 1 = on)");
sl->SetParameter("IF_STRENGTH = 1. #percent of intefernce (0.0 - 0.1)");
sl->SetParameter("INT_PT_MAX = 0.24 #Maximum pt considered, when interference is turned on");
sl->SetParameter("INT_PT_N_BINS =120 #Number of pt bins when interference is turned on");
sl->SetParameter("XSEC_METHOD = 1 # Set to 0 to use old method for calculating gamma-gamma luminosity");
sl->SetParameter("PYTHIA_FULL_EVENTRECORD = 0 # Write full pythia information to output (vertex, parents, daughter etc).");
sl->InitStarLight();
sl->PrintInputs(std::cout);
TClonesArray tca("TParticle", 100);
TLorentzVector v[2], vSum;
TH1* hM = new TH1D("hM", "STARLIGHT;M#(){#pi^{+}#pi^{-}}", 200, 3.0, 3.2);
TH1* hPt = new TH1D("hPt", "STARLIGHT;P_{T}#(){#pi^{+}#pi^{-}}", 80, 0., 2.);
TH1* hY = new TH1D("hY", "STARLIGHT;Y#(){#pi^{+}#pi^{-}}", 100,-10., 10.);
std::ofstream ofs("sl.txt");
TParticle *p;
for (Int_t counter(0); counter<20000; ) {
sl->GenerateEvent();
sl->BoostEvent();
sl->ImportParticles(&tca, "ALL");
Bool_t genOK = kTRUE;
TLorentzVector vSum;
for (Int_t i=0; i<tca.GetEntries() && genOK; ++i) {
p = (TParticle*)tca.At(i);
p->Momentum(v[i]);
vSum += v[i];
// genOK = TMath::Abs(v[i].Rapidity()) <= 1.5;
}
tca.Clear();
if (!genOK) continue;
Printf("%5d %d", counter, genOK);
++counter;
vSum = v[0] + v[1];
ofs << std::fixed << std::setprecision(4)
<< vSum.M() << " " << vSum.Perp() << " " << vSum.Rapidity() << " "
<< v[0].Eta() << " " << v[0].Px() << " " << v[0].Py() << " " << v[0].Pz() << " "
<< v[1].Eta() << " " << v[1].Px() << " " << v[1].Py() << " " << v[1].Pz()
<< std::endl;
hM->Fill(vSum.M());
hPt->Fill(vSum.Perp());
hY->Fill(vSum.Rapidity());
}
TFile::Open("sl.root", "RECREATE");
sl->Write();
gFile->Write();
hM->Draw();
c1->SaveAs("SL.pdf(");
hPt->Draw();
c1->SaveAs("SL.pdf");
hY->Draw();
c1->SaveAs("SL.pdf)");
}
void Example1(const char *inputFile)
{
gSystem->Load("libDelphes");
// Create chain of root trees
TChain chain("Delphes");
chain.Add(inputFile);
// Create object of class ExRootTreeReader
ExRootTreeReader *treeReader = new ExRootTreeReader(&chain);
Long64_t numberOfEntries = treeReader->GetEntries();
// Get pointers to branches used in this analysis
TClonesArray *branchJet = treeReader->UseBranch("Jet");
TClonesArray *branchElectron = treeReader->UseBranch("Electron");
TClonesArray *branchEvent = treeReader->UseBranch("Event");
// Book histograms
TH1 *histJetPT = new TH1F("jet_pt", "jet P_{T}", 100, 0.0, 100.0);
TH1 *histMass = new TH1F("mass", "M_{inv}(e_{1}, e_{2})", 100, 40.0, 140.0);
// Loop over all events
for(Int_t entry = 0; entry < numberOfEntries; ++entry)
{
// Load selected branches with data from specified event
treeReader->ReadEntry(entry);
//HepMCEvent *event = (HepMCEvent*) branchEvent -> At(0);
//LHEFEvent *event = (LHEFEvent*) branchEvent -> At(0);
//Float_t weight = event->Weight;
// If event contains at least 1 jet
if(branchJet->GetEntries() > 0)
{
// Take first jet
Jet *jet = (Jet*) branchJet->At(0);
// Plot jet transverse momentum
histJetPT->Fill(jet->PT);
// Print jet transverse momentum
cout << "Jet pt: "<<jet->PT << endl;
}
Electron *elec1, *elec2;
// If event contains at least 2 electrons
if(branchElectron->GetEntries() > 1)
{
// Take first two electrons
elec1 = (Electron *) branchElectron->At(0);
elec2 = (Electron *) branchElectron->At(1);
// Plot their invariant mass
histMass->Fill(((elec1->P4()) + (elec2->P4())).M());
}
}
// Show resulting histograms
histJetPT->Draw();
histMass->Draw();
}
// === Main Function ===================================================
void hadTau2(unsigned int id = 11,
const TString &effName = "../data/LostLepton_MuonEfficienciesFromWJetMC.root",
const TString &respTempl = "../data/HadTau_TauResponseTemplates.root",
int nEvts = -1) {
const bool isMC = ( id >= 10 );
// --- Declare the Output Histograms ---------------------------------
const TString title = isMC ? "Hadronic-Tau Closure Test" : "Hadronic-Tau Prediction";
// Control plot: muon pt in the control sample
TH1* hMuonPt = new TH1D("hMuonPt",title+";p_{T}(#mu^{gen}) [GeV];N(events)",50,0.,500.);
hMuonPt->Sumw2();
// Predicted distributions
TH1* hPredHt = new TH1D("hPredHt",title+";H_{T} [GeV];N(events)",25,500.,3000.);
hPredHt->Sumw2();
TH1* hPredMht = new TH1D("hPredMht",title+";#slash{H}_{T} [GeV];N(events)",20,200.,1200.);
hPredMht->Sumw2();
TH1* hPredNJets = new TH1D("hPredNJets",title+";N(jets);N(events)",9,3,12);
hPredNJets->Sumw2();
// In case of MC: true distributions
TH1* hTrueHt = static_cast<TH1*>(hPredHt->Clone("hTrueHt"));
TH1* hTrueMht = static_cast<TH1*>(hPredMht->Clone("hTrueMht"));
TH1* hTrueNJets = static_cast<TH1*>(hPredNJets->Clone("hTrueNJets"));
// Event yields in the different RA2 search bins
// First bin (around 0) is baseline selection
TH1* hPredYields = new TH1D("hPredYields",title+";;N(events)",37,-0.5,36.5);
hPredYields->Sumw2();
hPredYields->GetXaxis()->SetBinLabel(1,"baseline");
for(int bin = 2; bin <= hPredYields->GetNbinsX(); ++bin) {
TString label = "Bin ";
label += bin-1;
hPredYields->GetXaxis()->SetBinLabel(bin,label);
}
TH1* hTrueYields = static_cast<TH1*>(hPredYields->Clone("hTrueYields"));
// --- Tau Templates and Muon Efficiencies ---------------------------
// Interface to the tau response templates
TauResponse tauResp(respTempl);
// Interfaces to the muon acceptance as well as reconstruction and
// isolation efficiencies
LeptonAcceptance muonAcc(effName,LeptonAcceptance::nameMuonAcc());
LeptonEfficiency muonRecoEff(effName,LeptonEfficiency::nameMuonRecoEff());
LeptonEfficiency muonIsoEff(effName,LeptonEfficiency::nameMuonIsoEff());
// --- Analyse the events --------------------------------------------
// Interface to the event content
Event* evt = new Event(Sample::fileNameFullSample(id),nEvts);
// Loop over the events (tree entries)
while( evt->loadNext() ) {
// Select the control sample:
// - select events with exactly one well-reconstructed, isolated muon
// Use the muon to predict the energy deposits of the
// hadronically decaying tau:
// - scale the muon pt by a random factor drawn from the
// tau-reponse template to simulate the tau measurement
// - use the simulated tau-pt to predict HT, MHT, and N(jets)
if( evt->isoMuonsN() == 1 && evt->isoElectronsN() == 0 ) {
// The kinematic properties of the well-reconstructed, isolated muon
const float muPt = evt->isoMuonsPt()[0];
const float muEta = evt->isoMuonsEta()[0];
const float muPhi = evt->isoMuonsPhi()[0];
// Use only events where the muon is inside acceptance
if( muPt < TauResponse::ptMin() ) continue;
if( std::abs( muEta ) > TauResponse::etaMax() ) continue;
// "Cross cleaning": find the jet that corresponds to
// the muon. Associate the jet that is closest in
// in eta-phi space to the lepton
int muJetIdx = -1;
const float deltaRMax = 0.2;
if( !utils::findMatchedObject(muJetIdx,muEta,muPhi,evt->jetsEta(),evt->jetsPhi(),evt->jetsN(),deltaRMax) ) continue;
// Calculate RA2 selection-variables from "cleaned" jets
int selNJet = 0;
float selHt = 0.;
float selMhtX = 0.;
float selMhtY = 0.;
for(int jetIdx = 0; jetIdx < evt->jetsN(); ++jetIdx) { // Loop over reco jets
// Skip this jet if it is the muon
if( jetIdx == muJetIdx ) continue;
// Calculate NJet and HT
if( evt->jetsPt()[jetIdx] > Selection::htJetPtMin() && std::abs(evt->jetsEta()[jetIdx]) < Selection::htJetEtaMax() ) {
selNJet++;
selHt += evt->jetsPt()[jetIdx];
}
// Calculate MHT
if( evt->jetsPt()[jetIdx] > Selection::mhtJetPtMin() && std::abs(evt->jetsEta()[jetIdx]) < Selection::mhtJetEtaMax() ) {
selMhtX -= evt->jetsPt()[jetIdx]*cos(evt->jetsPhi()[jetIdx]);
selMhtY -= evt->jetsPt()[jetIdx]*sin(evt->jetsPhi()[jetIdx]);
}
} // End of loop over reco jets
// Select only events with at least 2 HT jets
if( selNJet < 2 ) continue;
// Plot the muon pt as control plot
hMuonPt->Fill(muPt);
// Get random number from tau-response template
// The template is chosen according to the muon pt
const float scale = tauResp.getRandom(muPt);
// Scale muon pt with tau response --> simulate tau jet pt
const float simTauJetPt = scale * muPt;
const float simTauJetEta = muEta;
const float simTauJetPhi = muPhi;
// Taking into account the simulated tau jet, recompute
// HT, MHT, and N(jets)
int simNJet = selNJet;
float simHt = selHt;
float simMhtX = selMhtX;
float simMhtY = selMhtY;
// If simulted tau-jet meets same criteria as as HT jets,
// recompute NJets and HT
if( simTauJetPt > Selection::htJetPtMin() && std::abs(muEta) < Selection::htJetEtaMax() ) {
simNJet++;
simHt += simTauJetPt;
}
// If simulated tau-jet meets same criteria as MHT jets,
// recompute MHT
if( simTauJetPt > Selection::mhtJetPtMin() && std::abs(muEta) < Selection::mhtJetEtaMax() ) {
simMhtX -= simTauJetPt*cos(muPhi);
simMhtY -= simTauJetPt*sin(muPhi);
}
const float simMht = sqrt( simMhtX*simMhtX + simMhtY*simMhtY );
const float simMhtPhi = std::atan2(simMhtY,simMhtX);
// Apply baseline selection
if( !Selection::nJets(simNJet) ) continue;
if( !Selection::ht(simHt) ) continue;
if( !Selection::mht(simMht) ) continue;
if( !deltaPhi(simMhtPhi,evt->jetsN(),evt->jetsPt(),evt->jetsEta(),evt->jetsPhi(),muJetIdx,simTauJetPt,simTauJetEta,simTauJetPhi) ) continue;
// Corrections to control sample
const double corrBRWToTauHad = 0.65; // Correction for the BR of hadronic tau decays
const double corrBRTauToMu = 1./1.15; // Correction for the fact that some muons could come from leptonic decays of taus from W decays
const double acc = muonAcc(evt->mht(),evt->nJets());
const double recoEff = muonRecoEff(evt->ht(),evt->mht(),evt->nJets());
const double isoEff = muonIsoEff(evt->ht(),evt->mht(),evt->nJets());
if( !( acc > 0. && recoEff > 0. && isoEff > 0. ) ) continue;
const double corrMuAcc = 1./acc; // Correction for muon acceptance
const double corrMuRecoEff = 1./recoEff; // Correction for muon reconstruction efficiency
const double corrMuIsoEff = 1./isoEff; // Correction for muon isolation efficiency
// The overall correction factor
const double corr = corrBRTauToMu * corrBRWToTauHad * corrMuAcc * corrMuRecoEff * corrMuIsoEff;
// Fill the prediction
hPredHt->Fill(simHt,corr);
hPredMht->Fill(simMht,corr);
hPredNJets->Fill(simNJet,corr);
// Predicted event yields
hPredYields->Fill(0.,corr);
const unsigned int searchBin = Selection::searchBin(simHt,simMht,simNJet);
if( searchBin > 0 ) {
hPredYields->Fill(searchBin,corr);
}
} // End if exactly one muon
if( isMC ) {
// Fill the 'truth' for comparison with the prediction
// Select only events where the W decayed into a hadronically
// decaying tau
if( !( evt->flgW() == 15 && evt->flgTau() == 1 ) ) continue;
// Apply baseline selection
if( !Selection::nJets(evt->nJets()) ) continue;
if( !Selection::ht(evt->ht()) ) continue;
if( !Selection::mht(evt->mht()) ) continue;
if( !Selection::deltaPhi(evt->deltaPhi1(),evt->deltaPhi2(),evt->deltaPhi3()) ) continue;
hTrueHt->Fill(evt->ht());
hTrueMht->Fill(evt->mht());
hTrueNJets->Fill(evt->nJets());
// True event yields
hTrueYields->Fill(0.);
const unsigned int searchBin = Selection::searchBin(evt->ht(),evt->mht(),evt->nJets());
if( searchBin > 0 ) {
hTrueYields->Fill(searchBin);
}
} // End isMC
} // End of loop over events
// --- Save the Histograms to File -----------------------------------
const TString outFileName = isMC ? "HadTau_WJetMC_Closure.root" : "HadTau_Data_Prediction.root";
TFile outFile(outFileName,"RECREATE");
hMuonPt->Write();
hTrueHt->Write();
hTrueMht->Write();
hTrueNJets->Write();
hTrueYields->Write();
hPredHt->Write();
hPredMht->Write();
hPredNJets->Write();
hPredYields->Write();
outFile.Close();
}
//_________________________________________________________________________________________________
void OccupancyInTimeBins(const char* input, const char* output)
{
timeResolutions.push_back(1);
timeResolutions.push_back(10);
timeResolutions.push_back(100);
AliRawReader* rawReader = AliRawReader::Create(input);
AliMUONRawStreamTrackerHP stream(rawReader);
stream.DisableWarnings();
stream.TryRecover(kTRUE);
int numberOfUsedEvents(0);
int numberOfBadEvents(0);
int numberOfEvents(0);
int numberOfPhysicsEvent(0);
int numberOfCalibrationEvent(0);
int numberOfEventsWithMCH(0);
int numberOfEventsWithoutCDH(0);
int runNumber(-1);
time_t runStart, runEnd;
AliMergeableCollection* hc(0x0);
AliCDBManager* cdbm = AliCDBManager::Instance();
if (!cdbm->IsDefaultStorageSet())
{
cdbm->SetDefaultStorage("local:///cvmfs/alice-ocdb.cern.ch/calibration/data/2015/OCDB");
}
cdbm->SetRun(0);
AliMpCDB::LoadAll();
while (rawReader->NextEvent() ) //&& numberOfEvents < 1000 )
{
rawReader->Reset();
++numberOfEvents;
if ( !rawReader->GetDataHeader() )
{
++numberOfEventsWithoutCDH;
}
if (rawReader->GetType() != AliRawEventHeaderBase::kPhysicsEvent)
{
if ( rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent )
{
++numberOfCalibrationEvent;
}
continue;
}
if (runNumber<0)
{
runNumber = rawReader->GetRunNumber();
GetTimeRange(runNumber,runStart,runEnd);
hc = new AliMergeableCollection("occ");
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
FillCollection(*hc,runStart,runEnd,timeResolutions[is]);
}
FillNumberOfPads(*hc);
}
++numberOfPhysicsEvent;
if ( numberOfPhysicsEvent % 5000 == 0 )
cout << Form("%12d events processed : %12d physics %d used ones %d bad ones [ %d with MCH information ]",
numberOfEvents,numberOfPhysicsEvent,numberOfUsedEvents,numberOfBadEvents,numberOfEventsWithMCH) << endl;
Bool_t mchThere(kFALSE);
for ( int iDDL = 0; iDDL < AliDAQ::NumberOfDdls("MUONTRK") && !mchThere; ++iDDL )
{
rawReader->Reset();
rawReader->Select("MUONTRK",iDDL,iDDL);
if (rawReader->ReadHeader() )
{
if (rawReader->GetEquipmentSize() ) mchThere = kTRUE;
}
}
if ( mchThere)
{
++numberOfEventsWithMCH;
}
else
{
continue;
}
Int_t buspatchId;
UShort_t manuId;
UChar_t manuChannel;
UShort_t adc;
stream.First();
std::map<int,int> bpValues;
while ( stream.Next(buspatchId,manuId,manuChannel,adc,kTRUE) )
{
bpValues[buspatchId]++;
}
for ( std::map<int,int>::const_iterator it = bpValues.begin(); it != bpValues.end(); ++it )
{
const int& buspatchId = it->first;
const int& bpvalue = it->second;
TString bpName = Form("BP%04d",buspatchId);
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
TH1* h = hc->Histo(Form("/BUSPATCH/HITS/%ds/%s",timeResolutions[is],bpName.Data()));
if (!h)
{
cout << "histogram not found" << endl;
continue;
}
h->Fill(rawReader->GetTimestamp(),bpvalue);
}
}
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
TH1* h = hc->Histo(Form("Nevents%ds",timeResolutions[is]));
if (!h)
{
cout << "histogram not found" << endl;
continue;
}
h->Fill(rawReader->GetTimestamp());
}
}
// Group BP histograms per DE then DDL then Chamber then Station
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
GroupByDE(*hc,timeResolutions[is]);
GroupByDDL(*hc,timeResolutions[is]);
GroupByChamber(*hc,timeResolutions[is]);
GroupByStation(*hc,timeResolutions[is]);
}
// make normalized versions of the histograms
Normalize(*hc);
TFile* fout = new TFile(output,"RECREATE");
hc->Write("occ");
delete fout;
}
//______________________________________________________________________________
void CBElemThresholds()
{
// load CaLib
gSystem->Load("libCaLib.so");
// configuration
const Char_t calibration[] = "LD2_Mar_13";
const Int_t set = 0;
const Double_t currThr = 2;
const Char_t* fADC = "/home/werthm/src/ROOT/acqu/acqu_user/data/Mar_13/CB/NaI.dat";
const Char_t* fIn = "/home/werthm/loc/presort/data/Mar_13/all.root";
// read gains
Double_t gain[720];
TCMySQLManager::GetManager()->ReadParameters("Data.CB.E1", calibration, set, gain, 720);
// create threshold histogram
TH1* hThr = new TH1F("Threshold distribution", "Threshold distribution", 200, 0, 20);
// read the ADC calibration file
TCReadARCalib c(fADC, kFALSE);
// get element list and loop over elements
TList* list = c.GetElements();
TIter next(list);
TCARElement* e;
TH1* h;
Int_t n = 0;
Int_t nAbove = 0;
Double_t thr[720];
Double_t min, max;
while ((e = (TCARElement*)next()))
{
// load histogram
TOLoader::LoadObject(fIn, TString::Format("ADC%s", e->GetADC()).Data(), &h, "", "q");
// find first filled bin
Double_t x = FindFirstFilledBin(h);
// calculate threshold in MeV
thr[n] = x * gain[n];
// exclude holes
if (!TCUtils::IsCBHole(n))
{
// save min/max
if (!n)
{
min = thr[n];
max = thr[n];
}
else
{
min = TMath::Min(min, thr[n]);
max = TMath::Max(max, thr[n]);
}
// fill distribution histo
hThr->Fill(thr[n]);
// count elements above currently set threshold
if (thr[n] > currThr) nAbove++;
}
// user info
printf("%3d %f\n", n, thr[n]);
// clean-up
delete h;
n++;
}
printf("Minimum threshold : %.2f\n", min);
printf("Maximum threshold : %.2f\n", max);
printf("Above threshold of %.2f MeV : %d (%.1f%%)\n", currThr, nAbove, 100.*nAbove/672.);
hThr->Draw();
}
//_________________________________________________________________________________________________
void FillNumberOfPads(AliMergeableCollection& hc)
{
// number of pads needed for normalization
TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
AliMpBusPatch* bp;
Int_t total(0);
AliMpDCSNamer dcs("TRACKER");
while ( ( bp = static_cast<AliMpBusPatch*>(next())) )
{
TH1* h = new TH1F(Form("BP%04d",bp->GetId()),"number of pads",1,0,1);
Int_t npads(0);
Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(bp->GetId());
AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
for ( Int_t i = 0; i < bp->GetNofManus(); ++i )
{
Int_t manuId = bp->GetManuId(i);
npads += de->NofChannelsInManu(manuId);
}
TH1* hde = hc.Histo(Form("/DE/NPADS/DE%04d",detElemId));
if (!hde)
{
hde = new TH1F(Form("DE%04d",detElemId),"number of pads",1,0,1);
hc.Adopt("/DE/NPADS/",hde);
}
hde->Fill(0.0,1.0*npads);
Int_t ddlId = de->GetDdlId() + AliDAQ::DdlIDOffset("MUONTRK");
TH1* hddl = hc.Histo(Form("/DDL/NPADS/DDL%d",ddlId));
if (!hddl)
{
hddl = new TH1F(Form("DDL%d",ddlId),"number of pads",1,0,1);
hc.Adopt("/DDL/NPADS/",hddl);
}
hddl->Fill(0.0,1.0*npads);
Int_t chamberId = 1+AliMpDEManager::GetChamberId(detElemId);
Int_t stationId = 1 + AliMpDEManager::GetChamberId(detElemId)/2;
TH1* hchamberSide(0x0);
TH1* hstationSide(0x0);
if (dcs.DCSAliasName(detElemId).Contains("Left"))
{
hchamberSide = hc.Histo(Form("/CHAMBER/NPADS/CHAMBER%dLEFT",chamberId));
if (!hchamberSide)
{
hchamberSide = new TH1F(Form("CHAMBER%dLEFT",chamberId),"number of pads",1,0,1);
hc.Adopt("/CHAMBER/NPADS/",hchamberSide);
}
hstationSide = hc.Histo(Form("/STATION/NPADS/STATION%dLEFT",stationId));
if (!hstationSide)
{
hstationSide = new TH1F(Form("STATION%dLEFT",stationId),"number of pads",1,0,1);
hc.Adopt("/STATION/NPADS/",hstationSide);
}
}
else
{
if (dcs.DCSAliasName(detElemId).Contains("Right"))
{
hchamberSide = hc.Histo(Form("/CHAMBER/NPADS/CHAMBER%dRIGHT",chamberId));
if (!hchamberSide)
{
hchamberSide = new TH1F(Form("CHAMBER%dRIGHT",chamberId),"number of pads",1,0,1);
hc.Adopt("/CHAMBER/NPADS/",hchamberSide);
}
hstationSide = hc.Histo(Form("/STATION/NPADS/STATION%dRIGHT",stationId));
if (!hstationSide)
{
hstationSide = new TH1F(Form("STATION%dRIGHT",stationId),"number of pads",1,0,1);
hc.Adopt("/STATION/NPADS/",hstationSide);
}
}
}
hchamberSide->Fill(0.0,1.0*npads);
hstationSide->Fill(0.0,1.0*npads);
TH1* hchamber = hc.Histo(Form("/CHAMBER/NPADS/CHAMBER%d",chamberId));
if (!hchamber)
{
hchamber = new TH1F(Form("CHAMBER%d",chamberId),"number of pads",1,0,1);
hc.Adopt("/CHAMBER/NPADS/",hchamber);
}
hchamber->Fill(0.0,1.0*npads);
TH1* hstation = hc.Histo(Form("/STATION/NPADS/STATION%d",stationId));
if (!hstation)
{
hstation = new TH1F(Form("STATION%d",stationId),"number of pads",1,0,1);
hc.Adopt("/STATION/NPADS/",hstation);
}
hstation->Fill(0.0,1.0*npads);
h->Fill(0.0,1.0*npads);
total += npads;
hc.Adopt("/BUSPATCH/NPADS/",h);
}
std::cout << "Total pads=" << total << std::endl;
}
// === Main Function ===================================================
void hadTau1(unsigned int id = 11, int nEvts = -1) {
// --- Declare the Output Histograms ---------------------------------
// The tau response templates
// They are filled for different bins in generated tau-lepton pt.
// The binning is encapsulated in ../Utils/TauResponse.h
std::vector<TH1*> hTauResp(TauResponse::nBins());
for(unsigned int i = 0; i < TauResponse::nBins(); ++i) {
hTauResp.at(i) = new TH1D(TauResponse::name(i),";p_{T}(visible) / p_{T}(generated);Probability",50,0.,2.5);
hTauResp.at(i)->Sumw2();
}
// Control histograms for the jet-tau matching efficiency
TH1* hNJetAll = new TH1D("hNJetAll",";N(jets)",10,0,10);
hNJetAll->Sumw2();
TH1* hNJetPass = static_cast<TH1*>(hNJetAll->Clone("hNJetPass"));
TH1* hHtAll = new TH1D("hHtAll",";H_{T} [GeV]",30,0,3000);
hHtAll->Sumw2();
TH1* hHtPass = static_cast<TH1*>(hHtAll->Clone("hHtPass"));
TH1* hMhtAll = new TH1D("hMhtAll",";#slash{H}_{T} [GeV]",20,0,2000);
hMhtAll->Sumw2();
TH1* hMhtPass = static_cast<TH1*>(hMhtAll->Clone("hMhtPass"));
// --- Analyse the events --------------------------------------------
// Interface to the event content
Event* evt = new Event(Sample::fileNameFullSample(id),nEvts);
// Loop over the events (tree entries)
while( evt->loadNext() ) {
// Select only events where the W decayed into a hadronically
// decaying tau
if( !(evt->flgW() == 15 && evt->flgTau() == 1) ) continue;
// Kinematic variables of generator-level tau
const float genTauPt = evt->genLeptonPt();
const float genTauEta = evt->genLeptonEta();
const float genTauPhi = evt->genLeptonPhi();
// Use only events where the tau is inside the muon acceptance
// because lateron we will apply the response to muon+jet events
if( genTauPt < TauResponse::ptMin() ) continue;
if( std::abs(genTauEta) > TauResponse::etaMax() ) continue;
// "Cross cleaning": find the jet that originates in the
// hadronic tau-decay. Associate the jet that is closest in
// deltaR to the tau. The distance has to be smaller than deltaRMax.
// First, fill counters before jet-tau matching
hNJetAll->Fill(evt->nJets());
hHtAll->Fill(evt->ht());
hMhtAll->Fill(evt->mht());
// Do the matching
int tauJetIdx = -1; // Will store the index of the jet matched to the tau
const float deltaRMax = genTauPt < 50. ? 0.2 : 0.1; // Increase deltaRMax at low pt to maintain high-enought matching efficiency
if( !utils::findMatchedObject(tauJetIdx,genTauEta,genTauPhi,evt->jetsEta(),evt->jetsPhi(),evt->jetsN(),deltaRMax) ) continue;
// Then, fill counters after matching
hNJetPass->Fill(evt->nJets());
hHtPass->Fill(evt->ht());
hMhtPass->Fill(evt->mht());
// Calculate RA2 selection-variables from "cleaned" jets,
// i.e. jets withouth the tau-jet
int selNJet = 0; // Number of HT jets (jets pt > 50 GeV and |eta| < 2.5)
for(int jetIdx = 0; jetIdx < evt->jetsN(); ++jetIdx) { // Loop over reco jets
// Skip this jet if it is the tau
if( jetIdx == tauJetIdx ) continue;
// Calculate NJet
if( evt->jetsPt()[jetIdx] > Selection::htJetPtMin() && std::abs(evt->jetsEta()[jetIdx]) < Selection::htJetEtaMax() ) selNJet++;
} // End of loop over reco jets
// Select only events with at least 2 HT jets
if( selNJet < 2 ) continue;
// Fill histogram with relative visible energy of the tau
// ("tau response template") for hadronically decaying taus
for(int jetIdx = 0; jetIdx < evt->jetsN(); ++jetIdx) { // Loop over reco jets
// Select tau jet
if( jetIdx == tauJetIdx ) {
// Get the response pt bin for the tau
const unsigned int ptBin = TauResponse::ptBin(genTauPt);
// Fill the corresponding response template
const double tauJetPt = evt->jetsPt()[jetIdx];
hTauResp.at(ptBin)->Fill( tauJetPt / genTauPt );
break; // End the jet loop once the tau jet has been found
}
} // End of loop over reco jets
} // End of loop over tree entries
// Normalize the response distributions to get the probability density
for(unsigned int i = 0; i < hTauResp.size(); ++i) {
if( hTauResp.at(i)->Integral("width") > 0. ) {
hTauResp.at(i)->Scale(1./hTauResp.at(i)->Integral("width"));
}
}
// Get the jet-tau matching efficiency
TH1* hMatchEffNJet = static_cast<TH1*>(hNJetPass->Clone("hMatchEffNJet"));
hMatchEffNJet->Divide(hNJetAll);
TH1* hMatchEffHt = static_cast<TH1*>(hHtPass->Clone("hMatchEffHt"));
hMatchEffHt->Divide(hHtAll);
TH1* hMatchEffMht = static_cast<TH1*>(hMhtPass->Clone("hMatchEffMht"));
hMatchEffMht->Divide(hMhtAll);
// --- Save the Histograms to File -----------------------------------
TFile outFile("../data/HadTau_TauResponseTemplates.root","RECREATE");
for(unsigned int i = 0; i < hTauResp.size(); ++i) {
hTauResp.at(i)->Write();
}
hMatchEffNJet->Write();
hMatchEffHt->Write();
hMatchEffMht->Write();
outFile.Close();
}
void delphes(const char *inputFile, const char* outputFileName)
{
gSystem->Load("libDelphes");
TChain *chain = new TChain("Delphes");
chain->Add(inputFile);
ExRootTreeReader *treeReader = new ExRootTreeReader(chain);
ExRootResult *result = new ExRootResult();
TH1* hNJet = result->AddHist1D("hNJets", "Jet multiplicity", "Multiplicity", "Events", 20, 0., 20.);
TH1* hNLeptons = result->AddHist1D("hNLeptons", "Lepton multiplicity", "Multiplicity", "Events", 20, 0., 20.);
TH1* hJetPt = result->AddHist1D("hJetPt", "Jet pT", "Transverse momentum p_{T} (GeV/c)", "Entries per 10GeV/c", 50, 0., 500.);
TH1* hNBjets = result->AddHist1D("hNBjets", "B Jet multiplicity", "B jet multiplicity", "Events", 20, 0., 20.);
TH1* hBjetPt = result->AddHist1D("hBjetPt", "B jet pT", "Transverse momentum p_{T} (GeV/c)", "Entries per 10GeV/c", 50, 0., 500.);
TH1* hST = result->AddHist1D("hST", "ST", "Scalar sum S_{T} (GeV/c)", "Events per 500GeV/c", 40, 0., 20000.);
// Analyze
TClonesArray *branchJet = treeReader->UseBranch("Jet");
TClonesArray *branchElectron = treeReader->UseBranch("Electron");
TClonesArray *branchMuon = treeReader->UseBranch("Muon");
TClonesArray *branchMissingET = treeReader->UseBranch("MissingET");
int nEventsTotal = 0, nEvents4J = 0, nEvents2B = 0, nEvents3B = 0, nEvents4B = 0;
int nEvents4J2B = 0, nEvents6J2B = 0, nEvents6J3B = 0;
// Loop over all events
for(Long64_t entry = 0, allEntries = treeReader->GetEntries(); entry < allEntries; ++entry)
{
double sT = 0;
int nLeptons = 0, nJets = 0, nBjets = 0;
treeReader->ReadEntry(entry);
for ( int i=0, n=branchMuon->GetEntriesFast(); i<n; ++i )
{
const Muon* muon = (Muon*)branchMuon->At(i);
const double muonPt = muon->PT;
if ( muonPt < 50 || fabs(muon->Eta) > 2.5 ) continue;
sT += muonPt;
nLeptons += 1;
}
for ( int i=0, n=branchElectron->GetEntriesFast(); i<n; ++i )
{
const Electron* electron = (Electron*)branchElectron->At(i);
const double electronPt = electron->PT;
if ( electronPt < 50 || fabs(electron->Eta) > 2.5 ) continue;
sT += electronPt;
nLeptons += 1;
}
for ( int i=0, n=branchJet->GetEntriesFast(); i<n; ++i )
{
const Jet* jet = (Jet*)branchJet->At(i);
const double jetPt = jet->PT;
if ( jetPt < 50 ) continue;
if ( fabs(jet->Eta) > 2.5 ) continue;
++nJets;
hJetPt->Fill(jetPt);
sT += jetPt;
if ( !jet->BTag ) continue;
++nBjets;
hBjetPt->Fill(jetPt);
}
hNLeptons->Fill(nLeptons);
hNJets->Fill(nJets);
hNBjets->Fill(nBjets);
// Analyse missing ET
if( branchMissingET->GetEntriesFast() > 0 )
{
const MissingET* met = (MissingET*)branchMissingET->At(0);
sT += met->MET;
}
hST->Fill(sT);
++nEventsTotal;
if ( nJets >= 4 ) ++nEvents4J;
if ( nBjets >= 2 ) ++nEvents2B;
if ( nBjets >= 3 ) ++nEvents3B;
if ( nBjets >= 4 ) ++nEvents4B;
if ( nJets >= 4 && nBjets >= 2 ) ++nEvents4J2B;
if ( nJets >= 6 && nBjets >= 2 ) ++nEvents6J2B;
if ( nJets >= 6 && nBjets >= 3 ) ++nEvents6J3B;
}
cout << inputFile << endl;
cout << "nJet4 " << 1.*nEvents4J/nEventsTotal << endl;
cout << "nBjet2 " << 1.*nEvents2B/nEventsTotal << endl;
cout << "nBjet3 " << 1.*nEvents3B/nEventsTotal << endl;
cout << "nBjet4 " << 1.*nEvents4B/nEventsTotal << endl;
cout << "nJet4 nBjet2 " << 1.*nEvents4J2B/nEventsTotal << endl;
cout << "nJet6 nBjet2 " << 1.*nEvents6J2B/nEventsTotal << endl;
cout << "nJet6 nBjet3 " << 1.*nEvents6J3B/nEventsTotal << endl;
//result->Print("png");
result->Write(outputFileName);
delete result;
delete treeReader;
delete chain;
}
