void rewritetrees(){
TString trees[] = {"iso2j1t" , "noniso2j1t" , "iso2j0t" , "noniso2j0t" , "iso3j2t" , "noniso3j2t" , "iso3j1t" , "noniso3j1t" };
struct{
float weight;
float mtw;
float met;
bool data;
bool qcd;
} info;
TFile* fout = TFile::Open("out.root" , "RECREATE");
for( int i=0 ; i < 8 ; i++){
cout << trees[i] << endl;
TTree* tree = (TTree*)( _file0->Get("Trees/" + trees[i] ) );
tree->SetBranchAddress( "info" , &info );
tree->Print();
TTree* tout = new TTree( tree->GetName() , tree->GetTitle() );
tout->SetAutoSave( 10000 );
tout->Branch( "weight" , &info.weight );
tout->Branch( "mtw" , &info.mtw);
tout->Branch( "met" , &info.met );
tout->Branch( "data" , &info.data );
tout->Branch( "qcd" , &info.qcd );
for(int j = 0 ; j < tree->GetEntries() ; j++){
tree->GetEntry(j);
tout->Fill();
//cout << i ;
}
}
fout->Write();
fout->Close();
}
//std::mutex mtx;
void ProcessFilePar(TString fileIn, TString fileOut, TString treename, vector<TString> friends, vector<TString> branches, vector<TString> newbranches, unsigned jobid = 0, unsigned NPAR = 1)
{
//mtx.lock(); //for threads
TFile *fin = new TFile(fileIn);
TTree *tjet = (TTree*)fin->Get(treename);
//mtx.unlock();
vector<TTree *> friendTrees;
vector<bool> sameFileFriend;
for (auto f:friends) {
auto fr = tokenize(f,":");
if (fr.size()==1) {tjet->AddFriend(fr[0]); sameFileFriend.push_back(true);}
else if (fr.size()==2) {tjet->AddFriend(fr[1],fr[0]); sameFileFriend.push_back(false);}
TTree *tfriend = (TTree*)fin->Get(f);
friendTrees.push_back(tfriend);
}
AddBranchesByCounter(tjet, branches);
for (unsigned i=0;i<friendTrees.size();i++) AddBranchesByCounter(friendTrees[i],branches);
//sort branches into categories
for (auto bName:branches) {
TBranch *b=tjet->GetBranch(bName);
if (b==0) cout <<"Branch "<<bName<<" doesn't exist!"<<endl;
//parse in case there is a tree name in the branch
auto branchtoken = tokenize(bName,".");
auto leafname = branchtoken[branchtoken.size()-1];
TObjArray *bl = b->GetListOfLeaves();
if (bl->GetEntries()>1)
cout <<" Branch "<<b->GetTitle()<<" has more than 1 leave. Taking first..."<<endl;
if (bl->GetEntries()==0) {
cout <<" Branch "<<b->GetTitle()<<" has no leaves! Skipping..."<<endl;
continue;
}
TLeaf * l = (TLeaf *)(*bl)[0];
//what's the type?
TString type = l->GetTypeName();
if (VERBOSE) cout<<l->GetTitle()<<endl;
//array?
bool array = l->GetLeafCount()!=0;
TString counter;
if (array) counter = l->GetLeafCount()->GetBranch()->GetName();
if (type=="Float_t")
{ if (array) {brVFloat.push_back(bName); brVFloatCounter.push_back(counter); }else brFloat.push_back(bName);}
else if (type=="Int_t")
{ if (array) {brVInt.push_back(bName); brVIntCounter.push_back(counter); }else brInt.push_back(bName);}
else cout << "Unsupported branch type "<<type<<" for branch "<<bName<<". Skipping..."<<endl;
}
//treat counters as ints only
AppendToListUniquely(brVIntCounter, brInt);
AppendToListUniquely(brVFloatCounter, brInt);
//too keep track of old branches, which cannot be read (todo: just check it...)
int noldbrInt = brInt.size(), noldbrFloat = brFloat.size(), noldbrVInt = brVInt.size(), noldbrVIntCounter = brVIntCounter.size(), noldbrVFloat = brVFloat.size(), noldbrVFloatCounter = brVFloatCounter.size();
//add new branches
ParseNewBranches(newbranches, brInt, brFloat, brVInt, brVIntCounter, brVFloat, brVFloatCounter);
//print for debugging
if (VERBOSE) {
cout<<"int : "; for (auto s:brInt) cout <<s<<", "; cout<<endl;
cout<<"float : "; for (auto s:brFloat) cout <<s<<", "; cout<<endl;
cout<<"Vint : "; for (auto s:brVInt) cout <<s<<", "; cout<<endl;
cout<<"Vfloat : "; for (auto s:brVFloat) cout <<s<<", "; cout<<endl;
cout<<"Vintcnt : "; for (auto s:brVIntCounter) cout <<s<<", "; cout<<endl;
cout<<"Vfloatcnt : "; for (auto s:brVFloatCounter) cout <<s<<", "; cout<<endl;
}
tjet->SetBranchStatus("*",1);
for (auto b:brVFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brVInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brInt) if (tjet->GetBranch(b)!=0) {unsigned f=0; tjet->SetBranchStatus(b,0,&f); if (VERBOSE) cout<<"turning off "<<b<<", found = "<<f<<endl;}
TFile *fout = new TFile(fileOut,"recreate");
TTree *tjetout;
//in case of one-to-many event - do not copy branches automatically!
if (useOneToOne) tjetout = tjet->CloneTree(0);
else tjetout = new TTree(tjet->GetName(),tjet->GetTitle());
//think about memory tree
// tjetout->SetDirectory(0);
tjetout->SetName(tjet->GetName());
//TTree *tjetout = new TTree("t","t");
//to see what is copied...
//tjetout->Print();
for (auto b:brVFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brVInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
vector<int> valIntIn(brInt.size()), valIntOut(brInt.size());
vector<float> valFloatIn(brFloat.size()), valFloatOut(brFloat.size());
vector<vector<int> >valVIntIn (brVInt.size()); vector<vector<int> >valVIntOut (brVInt.size());
vector<vector<float> >valVFloatIn (brVFloat.size()); vector<vector<float> >valVFloatOut (brVFloat.size());
for (unsigned i=0;i<brInt.size();i++) {
if (tjet->GetBranch(brInt[i])!=0)
tjet->SetBranchAddress(brInt[i],&valIntIn[i]);
if (tjetout->GetBranch(brInt[i])!=0) {//why would it?
tjetout->SetBranchAddress(brInt[i],&valIntOut[i]);
cout<<"branch "<<brInt[i]<<" already exist for some reason..."<<endl;
}
else //logical...
if (NonFriendBranch(tjet, brInt[i]))
tjetout->Branch(brInt[i],&valIntOut[i],Form("%s/I",brInt[i].Data()));
}
for (unsigned i=0;i<brFloat.size();i++) {
if (tjet->GetBranch(brFloat[i])!=0)
tjet->SetBranchAddress(brFloat[i],&valFloatIn[i]);
if (NonFriendBranch(tjet, brFloat[i]))
tjetout->Branch(brFloat[i],&valFloatOut[i],Form("%s/F",brFloat[i].Data()));
}
for (unsigned i=0;i<brVFloat.size();i++) {
if (tjet->GetBranch(brVFloat[i])!=0) {
valVFloatIn[i] = vector<float>(NMAX);
tjet->SetBranchAddress(brVFloat[i],&valVFloatIn[i][0]);
}
valVFloatOut[i] = vector<float>(NMAX);
if (NonFriendBranch(tjet, brVFloat[i]))
tjetout->Branch(brVFloat[i],&valVFloatOut[i][0],Form("%s[%s]/F",brVFloat[i].Data(),brVFloatCounter[i].Data()));
}
for (unsigned i=0;i<brVInt.size();i++) {
if (tjet->GetBranch(brVInt[i])) {
valVIntIn[i] = vector<int>(NMAX);
tjet->SetBranchAddress(brVInt[i],&valVIntIn[i][0]);
}
valVIntOut[i] = vector<int>(NMAX);
if (NonFriendBranch(tjet, brVInt[i]))
tjetout->Branch(brVInt[i],&valVIntOut[i][0],Form("%s[%s]/I",brVInt[i].Data(),brVIntCounter[i].Data()));
}
Long64_t nentries = tjet->GetEntries();
int nentries1 = nentries/NPAR*jobid;
int nentries2 = nentries/NPAR*(jobid+1);
nentries = nentries2-nentries1;
int oneperc = nentries/100; if (oneperc==0) oneperc = 1;
cout<<"Start processing..."<<endl;
TStopwatch s;
s.Start();
TTimeStamp t0;
double readTime = 0, processingTime = 0, copyToTime = 0, cloneTime=0, copyFromTime=0, fillTime = 0;
for (Long64_t i=0; i<nentries;i++) {
if (jobid==0 && i % oneperc == 0 && i>0) {
std::cout << std::fixed;
TTimeStamp t1; cout<<" \r"<<i/oneperc<<"% "<<" est. time "<<setprecision(2) <<(t1-t0)*nentries/(i+.1)<<" s ";
cout<<";Processing:"<<setprecision(2)<<processingTime/(t1-t0)*100<<" %";
cout<<";Copy1:"<<setprecision(2) <<copyToTime/(t1-t0)*100<<" %";
cout<<";Clone:"<<setprecision(2) <<cloneTime/(t1-t0)*100<<" %";
cout<<";Copy2:"<<setprecision(2) <<copyFromTime/(t1-t0)*100<<" %";
cout<<";Fill:"<<setprecision(2) <<fillTime/(t1-t0)*100<<" %";
cout<<";Read:"<<setprecision(2) <<readTime/(t1-t0)*100<<" %";
cout<<flush;
}
TTimeStamp tsRead0;
tjet->GetEntry(i+nentries1);
TTimeStamp tsRead1;
readTime+=tsRead1-tsRead0;
Everything ev;
TTimeStamp tsCpTo0;
for (unsigned j=0;j<brInt.size();j++) ev.PutInt(brInt[j],valIntIn[j]);
for (unsigned j=0;j<brFloat.size();j++) ev.PutFloat(brFloat[j],valFloatIn[j]);
for (unsigned j=0;j<brVFloat.size();j++) ev.PutVFloat(brVFloat[j],brVFloatCounter[j],valVFloatIn[j]);
for (unsigned j=0;j<brVInt.size();j++) ev.PutVInt(brVInt[j],brVIntCounter[j],valVIntIn[j]);
TTimeStamp tsCpTo1;
copyToTime+=tsCpTo1-tsCpTo0;
TTimeStamp tsCl0;
//think about: copy object (timing 10% ->3%)
//but it copies vectors, so push_back will add in the end...
// Everything evout = ev;
//or even reference(in place?) (->0.2%)
//Everything &evout = ev;
Everything evout = ev.CloneStructure();
TTimeStamp tsCl1;
cloneTime+=tsCl1-tsCl0;
bool exitEvent = false;
int counter = 0;
while (!exitEvent) {
TTimeStamp tsPr0;
if (useOneToOne) {
fProcessOneToOne(ev, evout);
evout.UpdateCounters();
exitEvent = true;
} else {
exitEvent = fProcessOneToMany(ev, evout, counter);
// if (!exitEvent) cout<<"event to write "<<counter<<endl;
counter++;
}
TTimeStamp tsPr1;
processingTime+=tsPr1-tsPr0;
//Everything evout = ev;
TTimeStamp tsCpFrom0;
for (unsigned j=0;j<brInt.size();j++) valIntOut[j] = evout.GetInt(brInt[j]);
for (unsigned j=0;j<brFloat.size();j++) {valFloatOut[j] = evout.GetFloat(brFloat[j]);
// cout<<brFloat[j]<<" "<<evout.GetFloat(brFloat[j])<<endl;
}
for (unsigned j=0;j<brVFloat.size();j++) valVFloatOut[j] = evout[brVFloat[j]];
for (unsigned j=0;j<brVInt.size();j++) valVIntOut[j] = evout.GetVInt(brVInt[j]);
TTimeStamp tsCpFrom1;
copyFromTime+=tsCpFrom1-tsCpFrom0;
TTimeStamp tsFill0;
tjetout->Fill();
TTimeStamp tsFill1;
fillTime+=tsFill1-tsFill0;
}
}
cout<<endl;
s.Stop();
cout<<"Done in ";s.Print();
tjetout->FlushBaskets();
tjetout->Write();
cout<<"Copying other trees..."<<endl;
for (unsigned i=0;i<friendTrees.size();i++) {
TTree *t = friendTrees[i];
if (sameFileFriend[i]) {
//TTree *triendout = t->CloneTree(-1,"fast");
TTree *triendout = t->CopyTree("","",nentries,nentries1);
triendout->Write();
}
}
fout->Close();
friendTrees.clear();
}
void KVSimDir::AnalyseFile(const Char_t* filename)
{
// Analyse ROOT file given as argument.
// If there is a TTree in the file, then we look at all of its branches until we find one
// containing objects which derive from KVEvent:
//
// -- if they inherit from KVSimEvent, we add the file to the list of simulated data:
// * a KVSimFile is created. The title of the TTree where data were found will
// be used as 'Information' on the nature of the simulation.
// -- if they inherit from KVReconstructedEvent, we add the file to the list of filtered data.
// * a KVSimFile is created. Informations on the filtered data are extracted from
// TNamed objects in the file with names 'Dataset', 'System', 'Run', 'Geometry'
// (type of geometry used, 'ROOT' or 'KV'), 'Origin' (i.e. the name of the simulation
// file which was filtered), 'Filter' (type of filter: Geo, GeoThresh or Full).
// These objects are automatically created when data is filtered using KVEventFiltering.
//
// Analysis of the file stops after the first TTree with a branch satisfying one of the
// two criteria is found (it is assumed that in each file there is only one TTree containing
// either simulated or filtered data).
Info("AnalyseFile", "Analysing file %s...", filename);
TString fullpath;
AssignAndDelete(fullpath, gSystem->ConcatFileName(GetDirectory(), filename));
TFile* file = TFile::Open(fullpath);
if (!file || file->IsZombie()) return;
// look for TTrees in file
TIter next(file->GetListOfKeys());
TKey* key;
while ((key = (TKey*)next())) {
TString cn = key->GetClassName();
if (cn == "TTree") {
// look for branch with KVEvent objects
TTree* tree = (TTree*)file->Get(key->GetName());
TSeqCollection* branches = tree->GetListOfBranches();
TIter nextB(branches);
TBranchElement* branch;
while ((branch = (TBranchElement*)nextB())) {
TString branch_classname = branch->GetClassName();
TClass* branch_class = TClass::GetClass(branch_classname, kFALSE, kTRUE);
if (branch_class && branch_class->InheritsFrom("KVEvent")) {
if (branch_class->InheritsFrom("KVSimEvent")) {
fSimData.Add(new KVSimFile(this, filename, tree->GetTitle(), tree->GetEntries(), tree->GetName(), branch->GetName()));
delete file;
return;
} else if (branch_class->InheritsFrom("KVReconstructedEvent")) {
// filtered data. there must be TNamed called 'Dataset', 'System', & 'Run' in the file.
TNamed* ds = (TNamed*)file->Get("Dataset");
TNamed* orig = (TNamed*)file->Get("Origin");
TNamed* sys = (TNamed*)file->Get("System");
TNamed* r = (TNamed*)file->Get("Run");
TNamed* g = (TNamed*)file->Get("Geometry");
TNamed* f = (TNamed*)file->Get("Filter");
TString dataset;
if (ds) dataset = ds->GetTitle();
TString system;
if (sys) system = sys->GetTitle();
TString run;
if (r) run = r->GetTitle();
TString origin;
if (orig) origin = orig->GetTitle();
TString geometry;
if (g) geometry = g->GetTitle();
TString filter;
if (f) filter = f->GetTitle();
Int_t run_number = run.Atoi();
fFiltData.Add(new KVSimFile(this, filename, tree->GetTitle(), tree->GetEntries(), tree->GetName(), branch->GetName(),
dataset, system, run_number, geometry, origin, filter));
delete file;
delete ds;
delete sys;
delete r;
delete f;
return;
}
}
}
}
}
}
void AnalyseEvents(ExRootTreeReader *treeReader, TTree *evtree)
{
//config parameters
bool runMMC_ = false;
double jetsPt_ =20;
double jetsEta_=5.0;
double bjetsPt_ =30;
double bjetsEta_ = 2.5;
double jetsDeltaR_ = 0.4;//deltaR matching
double jetleptonDeltaR_ = 0.3;
double leptonsDeltaR_ = 0.4;//deltaR matching
//double leptonIso_ = 0.15;
double muonPt2_ = 20;
double muonPt1_ = 20;
double muonsEta_ = 2.4;
double metPt_ = 20;
//create branches
Float_t b1_px =0;
Float_t b1_py =0;
Float_t b1_pz =0;
Float_t b1_eta = 0;
Float_t b1_phi = 0;
Float_t b1_pt =0;
Float_t b1_energy =0;
Float_t b2_px =0;
Float_t b2_py=0;
Float_t b2_pz=0;
Float_t b2_eta = 0;
Float_t b2_phi = 0;
Float_t b2_pt =0;
Float_t b2_energy=0;
Float_t htobb_px=0;
Float_t htobb_py=0;
Float_t htobb_pz=0;
Float_t htobb_energy=0;
Float_t htobb_mass =0;
Bool_t htobb=false;
Float_t genb1jet_px=0;
Float_t genb1jet_py=0;
Float_t genb1jet_pz=0;
Float_t genb1jet_eta=0;
Float_t genb1jet_phi=0;
Float_t genb1jet_pt=0;
Float_t genb1jet_energy=0;
Float_t genb2jet_px=0;
Float_t genb2jet_py=0;
Float_t genb2jet_pz=0;
Float_t genb2jet_eta=0;
Float_t genb2jet_phi=0;
Float_t genb2jet_pt=0;
Float_t genb2jet_energy=0;
Float_t dR_genb1jet=0;
Float_t dR_genb2jet=0;
Bool_t hasgenb1jet=false;
Bool_t hasgenb2jet=false;
Float_t dR_b1jet = 2.0;
Float_t dR_b2jet = 2.0;
Float_t b1jet_px=0;
Float_t b1jet_py=0;
Float_t b1jet_pz=0;
Float_t b1jet_eta=0;
Float_t b1jet_phi=0;
Float_t b1jet_pt=0;
Float_t b1jet_energy=0;
Float_t b2jet_px=0;
Float_t b2jet_py=0;
Float_t b2jet_pz=0;
Float_t b2jet_eta=0;
Float_t b2jet_phi=0;
Float_t b2jet_pt=0;
Float_t b2jet_energy=0;
Bool_t hasb1jet=false;
Bool_t hasb2jet=false;
Float_t mu1_px =0;
Float_t mu1_py =0;
Float_t mu1_pz =0;
Float_t mu1_eta =0;
Float_t mu1_phi =0;
Float_t mu1_pt =0;
Float_t mu1_energy =0;
Float_t mu2_px =0;
Float_t mu2_py =0;
Float_t mu2_pz =0;
Float_t mu2_eta =0;
Float_t mu2_phi =0;
Float_t mu2_pt =0;
Float_t mu2_energy =0;
Float_t nu1_px =0;
Float_t nu1_py =0;
Float_t nu1_pz =0;
Float_t nu1_eta =0;
Float_t nu1_phi =0;
Float_t nu1_energy =0;
Float_t nu2_px =0;
Float_t nu2_py =0;
Float_t nu2_pz =0;
Float_t nu2_eta =0;
Float_t nu2_phi =0;
Float_t nu2_energy =0;
Bool_t Wtomu2nu2=false;
Bool_t Wtomu1nu1=false;
Bool_t htoWW=false;
Float_t Muon1_beforeIso_px = 0.0;
Float_t Muon1_beforeIso_py = 0.0;
Float_t Muon1_beforeIso_pz = 0.0;
Float_t Muon1_beforeIso_eta = 0.0;
Float_t Muon1_beforeIso_phi = 0.0;
Float_t Muon1_beforeIso_pt = 0.0;
Float_t Muon1_beforeIso_energy = 0.0;
Float_t Muon2_beforeIso_px = 0.0;
Float_t Muon2_beforeIso_py = 0.0;
Float_t Muon2_beforeIso_pz = 0.0;
Float_t Muon2_beforeIso_eta = 0.0;
Float_t Muon2_beforeIso_phi = 0.0;
Float_t Muon2_beforeIso_pt = 0.0;
Float_t Muon2_beforeIso_energy = 0.0;
Float_t dR_mu1_beforeIso = 2.0;
Float_t dR_mu2_beforeIso = 2.0;
Bool_t Muon1_beforeIso_hasgenMu = false;
Bool_t Muon2_beforeIso_hasgenMu = false;
Bool_t Muon1_beforeIso_passIso = false;
Bool_t Muon2_beforeIso_passIso = false;
Bool_t hasMuon1_beforeIso = false;
Bool_t hasMuon2_beforeIso = false;
Float_t Muon1_px = 0;
Float_t Muon1_py = 0;
Float_t Muon1_pz = 0;
Float_t Muon1_eta = 0;
Float_t Muon1_phi = 0;
Float_t Muon1_pt = 0;
Float_t Muon1_energy = 0;
Float_t Muon2_px = 0;
Float_t Muon2_py = 0;
Float_t Muon2_pz = 0;
Float_t Muon2_eta = 0;
Float_t Muon2_phi = 0;
Float_t Muon2_pt = 0;
Float_t Muon2_energy = 0;
Float_t dR_mu1 = 2.0;
Float_t dR_mu2 = 2.0;
Bool_t Muon1_hasgenMu = false;
Bool_t Muon2_hasgenMu = false;
Float_t htoWW_px =0;
Float_t htoWW_py =0;
Float_t htoWW_pz =0;
Float_t htoWW_energy =0;
Float_t htoWW_mass = 0;
Float_t dR_b1l1;
Float_t dR_b1l2;
Float_t dR_b2l1;
Float_t dR_b2l2;
Float_t dR_l1l2;
Float_t dR_b1b2;
Float_t mass_l1l2;
Float_t mass_b1b2;
Float_t genmet = 0;
Float_t genmet_phi = 0;
Float_t genmet_px = 0;
Float_t genmet_py = 0;
Float_t met = 0;
Float_t met_phi = 0;
Float_t met_px = 0;
Float_t met_py = 0;
Float_t h2tohh_mass =0;
//additional cuts
Bool_t hasMET = false;
Bool_t hasGenMET = false;
Bool_t hastwomuons = false;
Bool_t hastwogenmuons = false;
Bool_t hasMuon1 = false;
Bool_t hasMuon2 = false;
Bool_t hasdRljet = false;
Bool_t h2tohh =false;
evtree->Branch("b1_px",&b1_px, "b1_px/F");
evtree->Branch("b1_py",&b1_py, "b1_py/F");
evtree->Branch("b1_pz",&b1_pz, "b1_pz/F");
evtree->Branch("b1_eta",&b1_eta, "b1_eta/F");
evtree->Branch("b1_phi",&b1_phi, "b1_phi/F");
evtree->Branch("b1_pt",&b1_pt, "b1_pt/F");
evtree->Branch("b1_energy",&b1_energy, "b1_energy/F");
evtree->Branch("b2_px",&b2_px, "b2_px/F");
evtree->Branch("b2_py",&b2_py, "b2_py/F");
evtree->Branch("b2_pz",&b2_pz, "b2_pz/F");
evtree->Branch("b2_eta",&b2_eta, "b2_eta/F");
evtree->Branch("b2_phi",&b2_phi, "b2_phi/F");
evtree->Branch("b2_pt",&b2_pt, "b2_pt/F");
evtree->Branch("b2_energy",&b2_energy, "b2_energy/F");
evtree->Branch("htobb_px",&htobb_px, "htobb_px/F");
evtree->Branch("htobb_py",&htobb_py, "htobb_py/F");
evtree->Branch("htobb_pz",&htobb_pz, "htobb_pz/F");
evtree->Branch("htobb_energy",&htobb_energy, "htobb_energy/F");
evtree->Branch("htobb_mass",&htobb_mass, "htobb_mass/F");
evtree->Branch("htobb",&htobb, "htobb/B");
evtree->Branch("genb1jet_px",&genb1jet_px, "genb1jet_px/F");
evtree->Branch("genb1jet_py",&genb1jet_py, "genb1jet_py/F");
evtree->Branch("genb1jet_pz",&genb1jet_pz, "genb1jet_pz/F");
evtree->Branch("genb1jet_eta",&genb1jet_eta, "genb1jet_eta/F");
evtree->Branch("genb1jet_phi",&genb1jet_phi, "genb1jet_phi/F");
evtree->Branch("genb1jet_pt",&genb1jet_pt, "genb1jet_pt/F");
evtree->Branch("genb1jet_energy",&genb1jet_energy, "genb1jet_energy/F");
evtree->Branch("genb2jet_px",&genb2jet_px, "genb2jet_px/F");
evtree->Branch("genb2jet_py",&genb2jet_py, "genb2jet_py/F");
evtree->Branch("genb2jet_pz",&genb2jet_pz, "genb2jet_pz/F");
evtree->Branch("genb2jet_eta",&genb2jet_eta, "genb2jet_eta/F");
evtree->Branch("genb2jet_phi",&genb2jet_phi, "genb2jet_phi/F");
evtree->Branch("genb2jet_pt",&genb2jet_pt, "genb2jet_pt/F");
evtree->Branch("genb2jet_energy",&genb2jet_energy, "genb2jet_energy/F");
evtree->Branch("dR_genb1jet", &dR_genb1jet,"dR_genb1jet/F");
evtree->Branch("dR_genb2jet", &dR_genb2jet,"dR_genb2jet/F");
evtree->Branch("hasgenb1jet",&hasgenb1jet, "hasgenb1jet/B");
evtree->Branch("hasgenb2jet",&hasgenb2jet, "hasgenb2jet/B");
evtree->Branch("b1jet_px",&b1jet_px, "b1jet_px/F");
evtree->Branch("b1jet_py",&b1jet_py, "b1jet_py/F");
evtree->Branch("b1jet_pz",&b1jet_pz, "b1jet_pz/F");
evtree->Branch("b1jet_eta",&b1jet_eta, "b1jet_eta/F");
evtree->Branch("b1jet_phi",&b1jet_phi, "b1jet_phi/F");
evtree->Branch("b1jet_pt",&b1jet_pt, "b1jet_pt/F");
evtree->Branch("b1jet_energy",&b1jet_energy, "b1jet_energy/F");
evtree->Branch("b2jet_px",&b2jet_px, "b2jet_px/F");
evtree->Branch("b2jet_py",&b2jet_py, "b2jet_py/F");
evtree->Branch("b2jet_pz",&b2jet_pz, "b2jet_pz/F");
evtree->Branch("b2jet_eta",&b2jet_eta, "b2jet_eta/F");
evtree->Branch("b2jet_phi",&b2jet_phi, "b2jet_phi/F");
evtree->Branch("b2jet_pt",&b2jet_pt, "b2jet_pt/F");
evtree->Branch("b2jet_energy",&b2jet_energy, "b2jet_energy/F");
evtree->Branch("dR_b1jet", &dR_b1jet,"dR_b1jet/F");
evtree->Branch("dR_b2jet", &dR_b2jet,"dR_b2jet/F");
evtree->Branch("hasb1jet",&hasb1jet, "hasb1jet/B");
evtree->Branch("hasb2jet",&hasb2jet, "hasb2jet/B");
evtree->Branch("hastwogenmuons",&hastwogenmuons, "hastwogenmuons/B");
evtree->Branch("hastwomuons",&hastwomuons, "hastwomuons/B");
evtree->Branch("mu1_px",&mu1_px, "mu1_px/F");
evtree->Branch("mu1_py",&mu1_py, "mu1_py/F");
evtree->Branch("mu1_pz",&mu1_pz, "mu1_pz/F");
evtree->Branch("mu1_eta",&mu1_eta, "mu1_eta/F");
evtree->Branch("mu1_phi",&mu1_phi, "mu1_phi/F");
evtree->Branch("mu1_pt",&mu1_pt, "mu1_pt/F");
evtree->Branch("mu1_energy",&mu1_energy, "mu1_energy/F");
evtree->Branch("nu1_px",&nu1_px, "nu1_px/F");
evtree->Branch("nu1_py",&nu1_py, "nu1_py/F");
evtree->Branch("nu1_pz",&nu1_pz, "nu1_pz/F");
evtree->Branch("nu1_eta",&nu1_eta, "nu1_eta/F");
evtree->Branch("nu1_phi",&nu1_phi, "nu1_phi/F");
evtree->Branch("nu1_energy",&nu1_energy, "nu1_energy/F");
evtree->Branch("mu2_px",&mu2_px, "mu2_px/F");
evtree->Branch("mu2_py",&mu2_py, "mu2_py/F");
evtree->Branch("mu2_pz",&mu2_pz, "mu2_pz/F");
evtree->Branch("mu2_eta",&mu2_eta, "mu2_eta/F");
evtree->Branch("mu2_phi",&mu2_phi, "mu2_phi/F");
evtree->Branch("mu2_pt",&mu2_pt, "mu2_pt/F");
evtree->Branch("mu2_energy",&mu2_energy, "mu2_energy/F");
evtree->Branch("nu2_px",&nu2_px, "nu2_px/F");
evtree->Branch("nu2_py",&nu2_py, "nu2_py/F");
evtree->Branch("nu2_pz",&nu2_pz, "nu2_pz/F");
evtree->Branch("nu2_eta",&nu2_eta, "nu2_eta/F");
evtree->Branch("nu2_phi",&nu2_phi, "nu2_phi/F");
evtree->Branch("nu2_energy",&nu2_energy, "nu2_energy/F");
evtree->Branch("htoWW_energy",&htoWW_energy);
evtree->Branch("htoWW_px",&htoWW_px,"htoWW_px/F");
evtree->Branch("htoWW_py",&htoWW_py,"htoWW_px/F");
evtree->Branch("htoWW_pz",&htoWW_pz,"htoWW_pz/F");
evtree->Branch("htoWW_mass",&htoWW_mass,"htoWW_mass/F");
evtree->Branch("Wtomu1nu1",&Wtomu1nu1,"Wtomu1nu1/B");
evtree->Branch("Wtomu2nu2",&Wtomu2nu2,"Wtomu2nu2/B");
evtree->Branch("htoWW",&htoWW,"htoWW/B");
evtree->Branch("Muon1_beforeIso_px",&Muon1_beforeIso_px, "Muon1_beforeIso_px/F");
evtree->Branch("Muon1_beforeIso_py",&Muon1_beforeIso_py, "Muon1_beforeIso_py/F");
evtree->Branch("Muon1_beforeIso_pz",&Muon1_beforeIso_pz, "Muon1_beforeIso_pz/F");
evtree->Branch("Muon1_beforeIso_eta",&Muon1_beforeIso_eta, "Muon1_beforeIso_eta/F");
evtree->Branch("Muon1_beforeIso_phi",&Muon1_beforeIso_phi, "Muon1_beforeIso_phi/F");
evtree->Branch("Muon1_beforeIso_pt",&Muon1_beforeIso_pt, "Muon1_beforeIso_pt/F");
evtree->Branch("Muon1_beforeIso_energy",&Muon1_beforeIso_energy, "Muon1_beforeIso_energy/F");
evtree->Branch("Muon2_beforeIso_px",&Muon2_beforeIso_px, "Muon2_beforeIso_px/F");
evtree->Branch("Muon2_beforeIso_py",&Muon2_beforeIso_py, "Muon2_beforeIso_py/F");
evtree->Branch("Muon2_beforeIso_pz",&Muon2_beforeIso_pz, "Muon2_beforeIso_pz/F");
evtree->Branch("Muon2_beforeIso_eta",&Muon2_beforeIso_eta, "Muon2_beforeIso_eta/F");
evtree->Branch("Muon2_beforeIso_phi",&Muon2_beforeIso_phi, "Muon2_beforeIso_phi/F");
evtree->Branch("Muon2_beforeIso_pt",&Muon2_beforeIso_pt, "Muon2_beforeIso_pt/F");
evtree->Branch("Muon2_beforeIso_energy",&Muon2_beforeIso_energy, "Muon2_beforeIso_energy/F");
evtree->Branch("dR_mu1_beforeIso",&dR_mu1_beforeIso, "dR_mu1_beforeIso/F");
evtree->Branch("dR_mu2_beforeIso",&dR_mu2_beforeIso, "dR_mu2_beforeIso/F");
evtree->Branch("hasMuon1_beforeIso",&hasMuon1_beforeIso, "hasMuon1_beforeIso/B");
evtree->Branch("hasMuon2_beforeIso",&hasMuon2_beforeIso, "hasMuon2_beforeIso/B");
evtree->Branch("Muon1_beforeIso_hasgenMu",&Muon1_beforeIso_hasgenMu, "Muon1_beforeIso_hasgenMu/B");
evtree->Branch("Muon2_beforeIso_hasgenMu",&Muon2_beforeIso_hasgenMu, "Muon2_beforeIso_hasgenMu/B");
evtree->Branch("Muon1_beforeIso_passIso",&Muon1_beforeIso_passIso, "Muon1_beforeIso_passIso/B");
evtree->Branch("Muon2_beforeIso_passIso",&Muon2_beforeIso_passIso, "Muon2_beforeIso_passIso/B");
evtree->Branch("Muon1_px",&Muon1_px, "Muon1_px/F");
evtree->Branch("Muon1_py",&Muon1_py, "Muon1_py/F");
evtree->Branch("Muon1_pz",&Muon1_pz, "Muon1_pz/F");
evtree->Branch("Muon1_eta",&Muon1_eta, "Muon1_eta/F");
evtree->Branch("Muon1_phi",&Muon1_phi, "Muon1_phi/F");
evtree->Branch("Muon1_pt",&Muon1_pt, "Muon1_pt/F");
evtree->Branch("Muon1_energy",&Muon1_energy, "Muon1_energy/F");
evtree->Branch("Muon2_px",&Muon2_px, "Muon2_px/F");
evtree->Branch("Muon2_py",&Muon2_py, "Muon2_py/F");
evtree->Branch("Muon2_pz",&Muon2_pz, "Muon2_pz/F");
evtree->Branch("Muon2_eta",&Muon2_eta, "Muon2_eta/F");
evtree->Branch("Muon2_phi",&Muon2_phi, "Muon2_phi/F");
evtree->Branch("Muon2_pt",&Muon2_pt, "Muon2_pt/F");
evtree->Branch("Muon2_energy",&Muon2_energy, "Muon2_energy/F");
evtree->Branch("dR_mu1",&dR_mu1, "dR_mu1/F");
evtree->Branch("dR_mu2",&dR_mu2, "dR_mu2/F");
evtree->Branch("hasMuon1",&hasMuon1, "hasMuon1/B");
evtree->Branch("hasMuon2",&hasMuon2, "hasMuon2/B");
evtree->Branch("Muon1_hasgenMu",&Muon1_hasgenMu, "Muon1_hasgenMu/B");
evtree->Branch("Muon2_hasgenMu",&Muon2_hasgenMu, "Muon2_hasgenMu/B");
evtree->Branch("dR_b1l1",&dR_b1l1, "dR_b1l1/F");
evtree->Branch("dR_b1l2",&dR_b1l2, "dR_b1l2/F");
evtree->Branch("dR_b2l1",&dR_b2l1, "dR_b2l1/F");
evtree->Branch("dR_b2l2",&dR_b2l2, "dR_b2l2/F");
evtree->Branch("dR_b1b2",&dR_b1b2, "dR_b1b2/F");
evtree->Branch("dR_l1l2",&dR_l1l2, "dR_l1l2/F");
evtree->Branch("mass_b1b2",&mass_b1b2, "mass_b1b2/F");
evtree->Branch("mass_l1l2",&mass_l1l2, "mass_l1l2/F");
evtree->Branch("genmet",&genmet,"genmet/F");
evtree->Branch("genmet_phi",&genmet_phi,"genmet_phi/F");
evtree->Branch("genmet_px",&genmet_px,"genmet_px/F");
evtree->Branch("genmet_py",&genmet_py,"genmet_py/F");
evtree->Branch("met",&met,"met/F");
evtree->Branch("met_phi",&met_phi,"met_phi/F");
evtree->Branch("met_px",&met_px,"met_px/F");
evtree->Branch("met_py",&met_py,"met_py/F");
evtree->Branch("hasGenMET",&hasGenMET, "hasGenMET/B");
evtree->Branch("hasMET",&hasMET, "hasMET/B");
evtree->Branch("hasdRljet",&hasdRljet, "hasdRljet/B");
evtree->Branch("h2tohh_mass",&h2tohh_mass,"h2tohh_mass/F");
evtree->Branch("h2tohh",&h2tohh,"h2tohh/B");
//loop over events 1. find h->b bbar; 2 find two bjets after cuts; 3 fill Tree
TClonesArray *branchParticle = treeReader->UseBranch("Particle");
TClonesArray *branchElectron = treeReader->UseBranch("Electron");
TClonesArray *branchPhoton = treeReader->UseBranch("Photon");
TClonesArray *branchMuon = treeReader->UseBranch("Muon");
TClonesArray *branchMuonBeforeIso = treeReader->UseBranch("MuonBeforeIso");
//TClonesArray *branchTrack = treeReader->UseBranch("Track");
// TClonesArray *branchTower = treeReader->UseBranch("Tower");
//TClonesArray *branchEFlowTrack = treeReader->UseBranch("EFlowTrack");
// TClonesArray *branchEFlowPhoton = treeReader->UseBranch("EFlowPhoton");
// TClonesArray *branchEFlowNeutralHadron = treeReader->UseBranch("EFlowNeutralHadron");
TClonesArray *branchJet = treeReader->UseBranch("Jet");
TClonesArray *branchGenJet = treeReader->UseBranch("GenJet");
TClonesArray *branchMissingET = treeReader->UseBranch("MissingET");
TClonesArray *branchGenMissingET = treeReader->UseBranch("GenMissingET");
Long64_t allEntries = treeReader->GetEntries();
cout << "** Chain contains " << allEntries << " events" << endl;
Long64_t entry;
Jet *genjet, *jet, *b1jet, *b2jet, *genb1jet, *genb2jet;
b1jet=0; b2jet=0; genb1jet =0; genb2jet=0;
MissingET *Met, *genMet;
Met=0;
GenParticle *particle, *genh2, *genhiggs1, *genhiggs2, *genhtobb, *genb1, *genb2;
genhtobb =0; genb1= 0; genb2=0;
GenParticle *genhtoWW, *genW1, *genW2, *genmu1, *genmu2, *gennu1, *gennu2;
genmu1=0; genmu2=0; gennu1=0; gennu2=0;
Electron *electron;
Photon *photon;
Muon *muon, *muon1, *muon2, *muon1_beforeIso, *muon2_beforeIso;
muon1 =0; muon2=0; muon1_beforeIso =0; muon2_beforeIso =0;
//Track *track;
//Tower *tower;
TLorentzVector momentum;
TLorentzVector Muon1_p4, Muon2_p4, b1jet_p4, b2jet_p4;
TLorentzVector totjets_lorentz = TLorentzVector();
//incase compilation error
genhtoWW = 0;
Int_t i;
// Loop over all events
//TFile *MMCfile = new TFile("testMMC.root", "recreate");
for(entry = 0; entry < allEntries; ++entry)
//for(entry = 0; entry < 1000; ++entry)
//for(entry = 0; entry < 10000; ++entry)
{
//gen
htobb = false;
hasgenb1jet = false;
hasgenb2jet = false;
Wtomu1nu1 = false;
Wtomu2nu2 = false;
hastwogenmuons = false;
htoWW = false;
hasGenMET = false;
//reco
hasb1jet = false;
hasb2jet = false;
hastwomuons = false;
hasMET = false;
hasMuon1_beforeIso = false;
hasMuon2_beforeIso = false;
hasMuon1 = false;
hasMuon2 = false;
hasdRljet = false;
dR_b1jet = 2.0;
dR_b2jet = 2.0;
dR_genb1jet = 2.0;
dR_genb2jet = 2.0;
dR_mu1 = 2.0; dR_mu2 = 2.0;
dR_mu1_beforeIso = 2.0; dR_mu2_beforeIso = 2.0;
// Load selected branches with data from specified event
treeReader->ReadEntry(entry);
cout <<" event id " << entry << endl;
/*for (i =0; i < branchParticle->GetEntries(); ++i){
genP = (GenParticle*) branchParticle->At(i);
//defualt M1 M2 D1 D2 is -1;
cout << " genP Id " << genP->PID <<" Pt " << genP->PT << " M1 "<< genP->M1<<" M2 "<< genP->M2 << " D1 "<< genP->D1 <<" D2 "<<genP->D2<< endl;
if ( genP->M1 >= 0 && genP->M1 <branchParticle->GetEntries()){
GenParticle *M1P= (GenParticle*) branchParticle->At(genP->M1);
cout <<" M1 Id " << M1P->PID <<" Pt " << M1P->PT << std::endl;
}
if ( genP->D1 >= 0 && genP->D1 <branchParticle->GetEntries()){
GenParticle *D1P= (GenParticle*) branchParticle->At(genP->D1);
cout <<" D1 Id " << D1P->PID <<" Pt " << D1P->PT << std::endl;
}
}*/
genh2 = (GenParticle*) branchParticle->At(0); //printGenParticle(genP);
h2tohh_mass = genh2->Mass;
genhiggs1 = (GenParticle*) branchParticle->At(genh2->D1);
//printGenParticle(genhiggs1);
genhiggs2 = (GenParticle*) branchParticle->At(genh2->D2);
//printGenParticle(genhiggs2);
while ((genhiggs1->D1>0 && ((GenParticle*)branchParticle->At(genhiggs1->D1))->PID == genhiggs1->PID)
|| (genhiggs1->D2>0 && ((GenParticle*)branchParticle->At(genhiggs1->D2))->PID == genhiggs1->PID)){
if (genhiggs1->D1>0 && ((GenParticle*)branchParticle->At(genhiggs1->D1))->PID == genhiggs1->PID)
genhiggs1 = (GenParticle*)branchParticle->At(genhiggs1->D1);
else genhiggs1 = (GenParticle*)branchParticle->At(genhiggs1->D2);
}
while ((genhiggs2->D1>0 && ((GenParticle*)branchParticle->At(genhiggs2->D1))->PID == genhiggs2->PID)
|| (genhiggs2->D2>0 && ((GenParticle*)branchParticle->At(genhiggs2->D2))->PID == genhiggs2->PID)){
if (genhiggs2->D1>0 && ((GenParticle*)branchParticle->At(genhiggs2->D1))->PID == genhiggs2->PID)
genhiggs2 = (GenParticle*)branchParticle->At(genhiggs2->D1);
else genhiggs2 = (GenParticle*)branchParticle->At(genhiggs2->D2);
}
if (abs(((GenParticle*)branchParticle->At(genhiggs1->D1))->PID) ==5 ) {
//printGenParticle(genhiggs1);
//printGenParticle((GenParticle*)branchParticle->At(genhiggs1->D1));
//printGenParticle((GenParticle*)branchParticle->At(genhiggs1->D2));
htobb = true;
genhtobb = genhiggs1;
}
else if (abs(((GenParticle*)branchParticle->At(genhiggs2->D1))->PID) ==5 ) {
//printGenParticle(genhiggs2);
//printGenParticle((GenParticle*)branchParticle->At(genhiggs2->D1));
//printGenParticle((GenParticle*)branchParticle->At(genhiggs2->D2));
htobb = true;
genhtobb = genhiggs2;
}
if (abs(((GenParticle*)branchParticle->At(genhiggs2->D1))->PID) == 24){
htoWW = true;
genhtoWW = genhiggs2;
}else if (abs(((GenParticle*)branchParticle->At(genhiggs1->D1))->PID) == 24){
htoWW = true;
genhtoWW = genhiggs1;
}
if (htobb){
if (((GenParticle*)branchParticle->At(genhtobb->D1))->PID == 5){
genb1 = (GenParticle*)branchParticle->At(genhtobb->D1);
genb2 = (GenParticle*)branchParticle->At(genhtobb->D2);
}
else {
genb1 = (GenParticle*)branchParticle->At(genhtobb->D2);
genb2 = (GenParticle*)branchParticle->At(genhtobb->D1);
}
//move on to "final state" bquarks
//printGenParticle(genhtobb);
getFinalState(genb1, branchParticle);
getFinalState(genb2, branchParticle);
b1_px = genb1->Px;
b1_py = genb1->Py;
b1_pz = genb1->Pz;
b1_eta = genb1->Eta;
b1_phi = genb1->Phi;
b1_pt = genb1->PT;
b1_energy = genb1->E;
b2_px = genb2->Px;
b2_py = genb2->Py;
b2_pz = genb2->Pz;
b2_eta = genb2->Eta;
b2_phi = genb2->Phi;
b2_pt = genb2->PT;
b2_energy = genb2->E;
TLorentzVector bbbar_lorentz = genb1->P4()+genb2->P4();
//cout << " bbbar_lorentz Mass "<< bbbar_lorentz.M(); bbbar_lorentz.Print();
htobb_px = genhtobb->Px; htobb_py= genhtobb->Py; htobb_pz = genhtobb->Pz; htobb_energy = genhtobb->E;
htobb_mass = genhtobb->Mass;
}
if (htoWW){
if (((GenParticle*)branchParticle->At(genhtoWW->D1))->PID == -24){//W-
genW1 = (GenParticle*)branchParticle->At(genhtoWW->D1); //to muon(13)
genW2 = (GenParticle*)branchParticle->At(genhtoWW->D2);
}
else {
genW1 = (GenParticle*)branchParticle->At(genhtoWW->D2);
genW2 = (GenParticle*)branchParticle->At(genhtoWW->D1);
}
getFinalState(genW1, branchParticle);
// cout <<" htoWW genW1 "; printGenParticle(genW1);
getFinalState(genW2, branchParticle);
//cout <<" htoWW genW2 "; printGenParticle(genW2);
if (genW1->D1>0 && ((GenParticle*)branchParticle->At(genW1->D1))->PID == 13){
genmu1 = (GenParticle*)branchParticle->At(genW1->D1);
gennu1 = (GenParticle*)branchParticle->At(genW1->D2);
Wtomu1nu1 = true;
}else if (genW1->D2 >0 && ((GenParticle*)branchParticle->At(genW1->D2))->PID == 13){
genmu1 = (GenParticle*)branchParticle->At(genW1->D2);
gennu1 = (GenParticle*)branchParticle->At(genW1->D1);
Wtomu1nu1 = true;
}
if (genW2->D1>0 && ((GenParticle*)branchParticle->At(genW2->D1))->PID == -13){
genmu2 = (GenParticle*)branchParticle->At(genW2->D1);
gennu2 = (GenParticle*)branchParticle->At(genW2->D2);
Wtomu2nu2 = true;
} else if (genW2->D1>0 && ((GenParticle*)branchParticle->At(genW2->D2))->PID == -13){
genmu2 = (GenParticle*)branchParticle->At(genW2->D2);
gennu2 = (GenParticle*)branchParticle->At(genW2->D1);
Wtomu2nu2 = true;
}
}
if (Wtomu1nu1){
getFinalState(genmu1, branchParticle);
getFinalState(gennu1, branchParticle);
mu1_px = genmu1->Px; mu1_py = genmu1->Py; mu1_pz = genmu1->Pz; mu1_energy = genmu1->E;
mu1_eta = genmu1->Eta; mu1_phi = genmu1->Phi; mu1_pt = genmu1->PT;
nu1_px = gennu1->Px; nu1_py = gennu1->Py; nu1_pz = gennu1->Pz; nu1_energy = gennu1->E;
nu1_eta = gennu1->Eta; nu1_phi = gennu1->Phi; nu1_pt = gennu1->PT;
//cout << "mu1 from W "; printGenParticle(genmu1);
}
if (Wtomu2nu2){
getFinalState(genmu2, branchParticle);
getFinalState(gennu2, branchParticle);
mu2_px = genmu2->Px; mu2_py = genmu2->Py; mu2_pz = genmu2->Pz; mu2_energy = genmu2->E;
mu2_eta = genmu2->Eta; mu2_phi = genmu2->Phi; mu2_pt = genmu2->PT;
nu2_px = gennu2->Px; nu2_py = gennu2->Py; nu2_pz = gennu2->Pz; nu2_energy = gennu2->E;
nu2_eta = gennu2->Eta; nu2_phi = gennu2->Phi; nu2_pt = gennu2->PT;
//cout << "mu2 from W "; printGenParticle(genmu2);
}
//loop all Gen jets
for (i =0; i< branchGenJet->GetEntries(); i++)
{
genjet = (Jet*) branchGenJet->At(i);
if (genjet->PT < bjetsPt_ || abs(genjet->Eta)> bjetsEta_) continue;
TLorentzVector genjet_p4 = genjet->P4();
if (htobb && genjet_p4.DeltaR(genb1->P4()) < dR_genb1jet && genjet_p4.DeltaR(genb1->P4())<jetsDeltaR_) {
dR_genb1jet = genjet_p4.DeltaR(genb1->P4());
genb1jet_px = genjet_p4.Px(); genb1jet_py = genjet_p4.Py(); genb1jet_pz=genjet_p4.Pz(); genb1jet_energy = genjet_p4.Energy();
genb1jet_eta = genjet_p4.Eta(); genb1jet_phi = genjet_p4.Phi();
genb1jet_pt = genjet_p4.Pt();
hasgenb1jet = true;
genb1jet = genjet;
}
if (htobb && genjet_p4.DeltaR(genb2->P4()) < dR_genb2jet && genjet_p4.DeltaR(genb2->P4()) < jetsDeltaR_){
dR_genb2jet = genjet_p4.DeltaR(genb2->P4());
genb2jet_px = genjet_p4.Px(); genb2jet_py = genjet_p4.Py(); genb2jet_pz=genjet_p4.Pz(); genb2jet_energy = genjet_p4.Energy();
genb2jet_eta = genjet_p4.Eta(); genb2jet_phi = genjet_p4.Phi();
genb2jet_pt = genjet_p4.Pt();
hasgenb2jet = true;
genb2jet = genjet;
}
}
//loop all reco jets
for (i =0; i< branchJet->GetEntries(); i++)
{
jet = (Jet*) branchJet->At(i);
if (jet->PT < jetsPt_ || abs(jet->Eta)> jetsEta_) continue;
totjets_lorentz +=jet->P4();
if (jet->PT < bjetsPt_ || abs(jet->Eta)> bjetsEta_) continue;
TLorentzVector jet_p4 = jet->P4();
if (htobb && jet_p4.DeltaR(genb1->P4()) < dR_b1jet && jet_p4.DeltaR(genb1->P4()) < jetsDeltaR_) {
b1jet = jet;
dR_b1jet = jet_p4.DeltaR(genb1->P4());
b1jet_p4 = jet_p4;
b1jet_px = jet_p4.Px(); b1jet_py = jet_p4.Py(); b1jet_pz=jet_p4.Pz(); b1jet_energy = jet_p4.Energy();
b1jet_eta = jet_p4.Eta(); b1jet_phi = jet_p4.Phi();
b1jet_pt = jet_p4.Pt();
hasb1jet = true;
}
if (htobb && jet_p4.DeltaR(genb2->P4()) < dR_b2jet && jet_p4.DeltaR(genb2->P4()) < jetsDeltaR_){
b2jet = jet;
dR_b2jet = jet_p4.DeltaR(genb2->P4());
b2jet_p4 = jet_p4;
b2jet_px = jet_p4.Px(); b2jet_py = jet_p4.Py(); b2jet_pz=jet_p4.Pz(); b2jet_energy = jet_p4.Energy();
b2jet_eta = jet_p4.Eta(); b2jet_phi = jet_p4.Phi();
b2jet_pt = jet_p4.Pt();
hasb2jet = true;
}
}
// b1jet should be different from b2jet
if (hasb1jet && hasb2jet && b1jet == b2jet){
hasb1jet = false;
hasb2jet = false;
}
else if (hasb1jet && hasb2jet){
//cout <<" b1jet Pt " << b1jet->PT <<" b2jet Pt " << b2jet->PT << endl;
// TLorentzVector htobb_jets = b1jet->P4()+b2jet->P4();
//cout <<" htobb_jet " << htobb_jets.M(); htobb_jets.Print();
}
// Analyse missing ET, generator level
if(branchGenMissingET->GetEntriesFast() > 0)
{
genMet = (MissingET*) branchGenMissingET->At(0);
genmet = genMet->MET;
genmet_phi = genMet->Phi;
genmet_px = genMet->P4().Px();
genmet_py = genMet->P4().Py();
if (genmet > metPt_) hasGenMET = true;
}
//apply muon cuts on muons
// Analyse missing ET, reco level
if(branchMissingET->GetEntriesFast() > 0)
{
Met = (MissingET*) branchMissingET->At(0);
met = Met->MET;
met_phi = Met->Phi;
met_px = Met->P4().Px();
met_py = Met->P4().Py();
if (met > metPt_) hasMET = true;
}
//apply muon cuts on muons
if (Wtomu1nu1 && Wtomu2nu2){
if (((genmu1->PT > muonPt1_ && genmu2->PT > muonPt2_) || (genmu1->PT > muonPt2_ && genmu2->PT > muonPt1_))
&& fabs(genmu1->Eta)<muonsEta_ && fabs(genmu2->Eta)< muonsEta_) hastwogenmuons =true;
}
//Loop over all Muon(before Isolation) in event
//how to check whether deltaR matching and matching genparticle has same performance??
//
for(i = 0; i < branchMuonBeforeIso->GetEntriesFast(); ++i)
{
muon = (Muon*) branchMuonBeforeIso->At(i);
TLorentzVector muon_p4 = muon->P4();
//
particle = (GenParticle*) muon->Particle.GetObject();
// printGenParticle(particle);
if (Wtomu1nu1 and muon->Charge<0 and muon_p4.DeltaR(genmu1->P4())<dR_mu1_beforeIso and muon_p4.DeltaR(genmu1->P4())<leptonsDeltaR_) {
dR_mu1_beforeIso = muon_p4.DeltaR(genmu1->P4());
muon1_beforeIso = muon;
hasMuon1_beforeIso = true;
if (particle == genmu1) Muon1_beforeIso_hasgenMu = true;
}
else if(Wtomu2nu2 and muon->Charge>0 and muon_p4.DeltaR(genmu2->P4())<dR_mu2_beforeIso and muon_p4.DeltaR(genmu2->P4())<leptonsDeltaR_) {
dR_mu2_beforeIso = muon_p4.DeltaR(genmu2->P4());
muon2_beforeIso = muon;
hasMuon2_beforeIso = true;
if (particle == genmu2) Muon2_beforeIso_hasgenMu = true;
}
if (hasMuon1_beforeIso) std::cout <<" has reco Muon1 before Iso " << std::endl;
if (hasMuon2_beforeIso) std::cout <<" has reco Muon2 before Iso " << std::endl;
}
if (hasMuon1_beforeIso){
Muon1_beforeIso_px = muon1_beforeIso->P4().Px(); Muon1_beforeIso_py = muon1_beforeIso->P4().Py(); Muon1_beforeIso_pz = muon1_beforeIso->P4().Pz(); Muon1_beforeIso_energy = muon1_beforeIso->P4().E();
Muon1_beforeIso_eta = muon1_beforeIso->P4().Eta(); Muon1_beforeIso_phi = muon1_beforeIso->P4().Phi();
Muon1_pt = muon1_beforeIso->PT;
}
if (hasMuon2_beforeIso){
Muon2_beforeIso_px = muon2_beforeIso->P4().Px(); Muon2_beforeIso_py = muon2_beforeIso->P4().Py(); Muon2_beforeIso_pz = muon2_beforeIso->P4().Pz(); Muon2_beforeIso_energy = muon2_beforeIso->P4().E();
Muon2_beforeIso_eta = muon2_beforeIso->P4().Eta(); Muon2_beforeIso_phi = muon2_beforeIso->P4().Phi();
Muon2_pt = muon2_beforeIso->PT;
}
// Loop over all Muon in event, reco muon
for(i = 0; i < branchMuon->GetEntriesFast(); ++i)
{
muon = (Muon*) branchMuon->At(i);
TLorentzVector muon_p4 = muon->P4();
particle = (GenParticle*) muon->Particle.GetObject();
// printGenParticle(particle);
if (hasMuon1_beforeIso and muon->Eta == muon1_beforeIso->Eta and muon->Phi == muon1_beforeIso->Phi) Muon1_beforeIso_passIso = true;
if (hasMuon2_beforeIso and muon->Eta == muon2_beforeIso->Eta and muon->Phi == muon2_beforeIso->Phi) Muon2_beforeIso_passIso = true;
//check charge and deltaR, genmu1: charge<0, genmu2: charge>0
if (Wtomu1nu1 and muon->Charge<0 and muon_p4.DeltaR(genmu1->P4())<dR_mu1 and muon_p4.DeltaR(genmu1->P4())<leptonsDeltaR_) {
dR_mu1 = muon_p4.DeltaR(genmu1->P4());
muon1 = muon;
hasMuon1 = true;
if (particle == genmu1) Muon1_hasgenMu = true;
}
else if (Wtomu2nu2 and muon->Charge>0 and muon_p4.DeltaR(genmu2->P4())<dR_mu2 and muon_p4.DeltaR(genmu2->P4())<leptonsDeltaR_) {
dR_mu2 = muon_p4.DeltaR(genmu2->P4());
muon2 = muon;
hasMuon2 = true;
if (particle == genmu2) Muon2_hasgenMu = true;
}
if (hasMuon1) std::cout <<" has reco Muon1 " << std::endl;
if (hasMuon2) std::cout <<" has reco Muon2 " << std::endl;
//cout <<" muon eta " << muon->Eta << " phi " << muon->Phi << " Pt "<< muon->PT << endl;
}
if (hasMuon1){
Muon1_p4 = muon1->P4();
Muon1_px = muon1->P4().Px(); Muon1_py = muon1->P4().Py(); Muon1_pz = muon1->P4().Pz(); Muon1_energy = muon1->P4().E();
Muon1_eta = muon1->P4().Eta(); Muon1_phi = muon1->P4().Phi(); Muon1_pt = muon1->PT;
}
if (hasMuon2){
Muon2_p4 = muon2->P4();
Muon2_px = muon2->P4().Px(); Muon2_py = muon2->P4().Py(); Muon2_pz = muon2->P4().Pz(); Muon2_energy = muon2->P4().E();
Muon2_eta = muon2->P4().Eta(); Muon2_phi = muon2->P4().Phi(); Muon2_pt = muon2->PT;
}
if (hasMuon1 && hasMuon2){
if (((muon1->PT > muonPt1_ && muon2->PT > muonPt2_) || (muon1->PT > muonPt2_ && muon2->PT > muonPt1_))
&& fabs(muon1->Eta)<muonsEta_ && fabs(muon2->Eta)< muonsEta_) hastwomuons =true;
}
// Loop over all electrons in event
for(i = 0; i < branchElectron->GetEntriesFast(); ++i)
{
electron = (Electron*) branchElectron->At(i);
particle = (GenParticle*) electron->Particle.GetObject();
//cout <<" electron "; printGenParticle(particle);
}
// Loop over all photons in event
for(i = 0; i < branchPhoton->GetEntriesFast(); ++i)
{
photon = (Photon*) branchPhoton->At(i);
// skip photons with references to multiple particles
if(photon->Particles.GetEntriesFast() != 1) continue;
particle = (GenParticle*) photon->Particles.At(0);
//cout <<" photon "; printGenParticle(particle);
}
if (hasb1jet and hasb2jet and hasMuon1 and hasMuon2){
dR_b1l1 = b1jet_p4.DeltaR(Muon1_p4);
dR_b1l2 = b1jet_p4.DeltaR(Muon2_p4);
dR_b2l1 = b2jet_p4.DeltaR(Muon1_p4);
dR_b2l2 = b2jet_p4.DeltaR(Muon2_p4);
dR_b1b2 = b1jet_p4.DeltaR(b2jet_p4);
dR_l1l2 = Muon1_p4.DeltaR(Muon2_p4);
TLorentzVector ll_p4 = Muon1_p4+Muon2_p4;
TLorentzVector bjets_p4 = b1jet_p4+b2jet_p4;
mass_l1l2 = ll_p4.M();
mass_b1b2 = bjets_p4.M();
if (dR_b1l1>jetleptonDeltaR_ and dR_b1l2>jetleptonDeltaR_ and dR_b2l1>jetleptonDeltaR_ and dR_b2l2>jetleptonDeltaR_) hasdRljet =true;
}
// Loop over all tracks in event
/*
for(i = 0; i < branchTrack->GetEntriesFast(); ++i)
{
track = (Track*) branchTrack->At(i);
particle = (GenParticle*) track->Particle.GetObject();
cout <<" Track "; printGenParticle(particle);
}*/
// calculate the DeltaR between bjet and lepton
h2tohh = (htobb and Wtomu1nu1 and Wtomu2nu2);
if (runMMC_ && h2tohh && hasgenb1jet && hasgenb2jet){
TLorentzVector bjets_lorentz=genb1jet->P4()+genb2jet->P4();
cout <<" m_{bjets} " << bjets_lorentz.M(); bjets_lorentz.Print();
TLorentzVector met_lorentz = Met->P4();
bool simulation_ = true;
bool weightfromonshellnupt_func = false;
bool weightfromonshellnupt_hist = true;
bool weightfromonoffshellWmass_hist=true;
int iterations = 100000;
std::string RefPDFfile("MMCRefPDF.ROOT");
bool useMET = true;
int onshellMarker_;
if (genW1->Mass > genW2->Mass) onshellMarker_=1;
else onshellMarker_=2;
// rescale bjets in MMC?????
//MMC *thismmc = new MMC();
MMC *thismmc = new MMC(genmu1->P4(), genmu2->P4(), bjets_lorentz, totjets_lorentz,
met_lorentz, gennu1->P4(), gennu2->P4(), genb1->P4()+genb2->P4(),
genh2->P4(), onshellMarker_,// only for simulation
simulation_, entry, weightfromonshellnupt_func, weightfromonshellnupt_hist, weightfromonoffshellWmass_hist,
iterations, RefPDFfile, useMET);
thismmc->runMMC();
TTree *mmctree = (thismmc->getMMCTree())->CloneTree();
std::cout <<"MMCTree entries " << (thismmc->getMMCTree())->GetEntries() << std::endl;
std::cout <<"testtree entries " << mmctree->GetEntries()<<" title "<< mmctree->GetTitle() << std::endl;
//esttree->SetDirectory((TDirectory*)MMCfile);
//MMCfile->WriteObject(mmctree,mmctree->GetTitle());
delete thismmc;
}
//fill branches
if (htobb || (Wtomu1nu1 && Wtomu2nu2)) evtree->Fill();
}
// MMCfile->Close();
//delete MMCfile;
//evtree->Fill();
}
void DiHiggstollbb::DiHiggstollbbrun()
{
//loop over events 1. find h->b bbar; 2 find two bjets after cuts; 3 fill Tree
// TClonesArray *branchParticle = treeReader->UseBranch("Particle");
TClonesArray *branchElectron = treeReader->UseBranch("Electron");
TClonesArray *branchPhoton = treeReader->UseBranch("Photon");
TClonesArray *branchMuon = treeReader->UseBranch("Muon");
//TClonesArray *branchMuonBeforeIso = treeReader->UseBranch("MuonBeforeIso");
//TClonesArray *branchTrack = treeReader->UseBranch("Track");
// TClonesArray *branchTower = treeReader->UseBranch("Tower");
//TClonesArray *branchEFlowTrack = treeReader->UseBranch("EFlowTrack");
// TClonesArray *branchEFlowPhoton = treeReader->UseBranch("EFlowPhoton");
// TClonesArray *branchEFlowNeutralHadron = treeReader->UseBranch("EFlowNeutralHadron");
TClonesArray *branchJet = treeReader->UseBranch("Jet");
//TClonesArray *branchGenJet = treeReader->UseBranch("GenJet");
TClonesArray *branchMissingET = treeReader->UseBranch("MissingET");
//TClonesArray *branchGenMissingET = treeReader->UseBranch("GenMissingET");
long allEntries = treeReader->GetEntries();
cout << "** Chain contains " << allEntries << " events" << endl;
long entry;
Jet *jet, *b1jet, *b2jet;
b1jet=0; b2jet=0;
MissingET *Met;
Met=0;
//GenParticle *particle, *genh2, *genhiggs1, *genhiggs2, *genhtobb, *genb1, *genb2;
//genhtobb =0; genb1= 0; genb2=0;
//GenParticle *genhtoWW, *genW1, *genW2, *genmu1, *genmu2, *gennu1, *gennu2;
//genmu1=0; genmu2=0; gennu1=0; gennu2=0;
Electron *electron;
Photon *photon;
Muon *muon, *muon1, *muon2;// *muon1_beforeIso, *muon2_beforeIso;
muon1 =0; muon2=0; //muon1_beforeIso =0; muon2_beforeIso =0;
//Track *track;
//Tower *tower;
TLorentzVector momentum;
TLorentzVector Muon1_p4, Muon2_p4, b1jet_p4, b2jet_p4;
TLorentzVector totjets_lorentz = TLorentzVector();
//incase compilation error
int i =0;
// Loop over all events
//TFile *MMCfile = new TFile("testMMC.root", "recreate");
if (nEvents < 0) nEvents = allEntries;
for(entry = 0; entry < nEvents; ++entry)
//for(entry = 0; entry < 1000; ++entry)
//for(entry = 0; entry < 10000; ++entry)
{
//gen
initBranches();
// Load selected branches with data from specified event
bool readsuccess = treeReader->ReadEntry(entry);
if (not readsuccess) {
cout <<"can not read Entry through treeReader" << endl;
exit(0);
}
cout <<" event id " << entry << endl;
/*for (i =0; i < branchParticle->GetEntries(); ++i){
genP = (GenParticle*) branchParticle->At(i);
//defualt M1 M2 D1 D2 is -1;
cout << " genP Id " << genP->PID <<" Pt " << genP->PT << " M1 "<< genP->M1<<" M2 "<< genP->M2 << " D1 "<< genP->D1 <<" D2 "<<genP->D2<< endl;
if ( genP->M1 >= 0 && genP->M1 <branchParticle->GetEntries()){
GenParticle *M1P= (GenParticle*) branchParticle->At(genP->M1);
cout <<" M1 Id " << M1P->PID <<" Pt " << M1P->PT << std::endl;
}
if ( genP->D1 >= 0 && genP->D1 <branchParticle->GetEntries()){
GenParticle *D1P= (GenParticle*) branchParticle->At(genP->D1);
cout <<" D1 Id " << D1P->PID <<" Pt " << D1P->PT << std::endl;
}
}
genh2 = (GenParticle*) branchParticle->At(0); //printGenParticle(genP);
//printGenParticle(genh2);
h2tohh_mass = genh2->Mass;
genhiggs1 = (GenParticle*) branchParticle->At(genh2->D1);
genhiggs2 = (GenParticle*) branchParticle->At(genh2->D2);
//printGenParticle(genhiggs2);
while ((genhiggs1->D1>0 && ((GenParticle*)branchParticle->At(genhiggs1->D1))->PID == genhiggs1->PID)
|| (genhiggs1->D2>0 && ((GenParticle*)branchParticle->At(genhiggs1->D2))->PID == genhiggs1->PID)){
if (genhiggs1->D1>0 && ((GenParticle*)branchParticle->At(genhiggs1->D1))->PID == genhiggs1->PID)
genhiggs1 = (GenParticle*)branchParticle->At(genhiggs1->D1);
else genhiggs1 = (GenParticle*)branchParticle->At(genhiggs1->D2);
}
while ((genhiggs2->D1>0 && ((GenParticle*)branchParticle->At(genhiggs2->D1))->PID == genhiggs2->PID)
|| (genhiggs2->D2>0 && ((GenParticle*)branchParticle->At(genhiggs2->D2))->PID == genhiggs2->PID)){
if (genhiggs2->D1>0 && ((GenParticle*)branchParticle->At(genhiggs2->D1))->PID == genhiggs2->PID)
genhiggs2 = (GenParticle*)branchParticle->At(genhiggs2->D1);
else genhiggs2 = (GenParticle*)branchParticle->At(genhiggs2->D2);
}
if (abs(((GenParticle*)branchParticle->At(genhiggs1->D1))->PID) ==5 ) {
//printGenParticle(genhiggs1);
//printGenParticle((GenParticle*)branchParticle->At(genhiggs1->D1));
//printGenParticle((GenParticle*)branchParticle->At(genhiggs1->D2));
htobb = true;
genhtobb = genhiggs1;
}
else if (abs(((GenParticle*)branchParticle->At(genhiggs2->D1))->PID) ==5 ) {
//printGenParticle(genhiggs2);
//printGenParticle((GenParticle*)branchParticle->At(genhiggs2->D1));
//printGenParticle((GenParticle*)branchParticle->At(genhiggs2->D2));
htobb = true;
genhtobb = genhiggs2;
}
if (abs(((GenParticle*)branchParticle->At(genhiggs2->D1))->PID) == 24){
htoWW = true;
genhtoWW = genhiggs2;
}else if (abs(((GenParticle*)branchParticle->At(genhiggs1->D1))->PID) == 24){
htoWW = true;
genhtoWW = genhiggs1;
}
if (htobb){
if (((GenParticle*)branchParticle->At(genhtobb->D1))->PID == 5){
genb1 = (GenParticle*)branchParticle->At(genhtobb->D1);
genb2 = (GenParticle*)branchParticle->At(genhtobb->D2);
}
else {
genb1 = (GenParticle*)branchParticle->At(genhtobb->D2);
genb2 = (GenParticle*)branchParticle->At(genhtobb->D1);
}
//move on to "final state" bquarks
//printGenParticle(genhtobb);
getFinalState(genb1, branchParticle);
getFinalState(genb2, branchParticle);
b1_px = genb1->Px;
b1_py = genb1->Py;
b1_pz = genb1->Pz;
b1_eta = genb1->Eta;
b1_phi = genb1->Phi;
b1_pt = genb1->PT;
b1_energy = genb1->E;
b2_px = genb2->Px;
b2_py = genb2->Py;
b2_pz = genb2->Pz;
b2_eta = genb2->Eta;
b2_phi = genb2->Phi;
b2_pt = genb2->PT;
b2_energy = genb2->E;
TLorentzVector bbbar_lorentz = genb1->P4()+genb2->P4();
//cout << " bbbar_lorentz Mass "<< bbbar_lorentz.M(); bbbar_lorentz.Print();
htobb_px = genhtobb->Px; htobb_py= genhtobb->Py; htobb_pz = genhtobb->Pz; htobb_energy = genhtobb->E;
htobb_mass = genhtobb->Mass;
}
if (htoWW){
if (((GenParticle*)branchParticle->At(genhtoWW->D1))->PID == -24){//W-
genW1 = (GenParticle*)branchParticle->At(genhtoWW->D1); //to muon(13)
genW2 = (GenParticle*)branchParticle->At(genhtoWW->D2);
}
else {
genW1 = (GenParticle*)branchParticle->At(genhtoWW->D2);
genW2 = (GenParticle*)branchParticle->At(genhtoWW->D1);
}
getFinalState(genW1, branchParticle);
//cout <<" htoWW genW1 "; printGenParticle(genW1);
getFinalState(genW2, branchParticle);
//cout <<" htoWW genW2 "; printGenParticle(genW2);
if (genW1->D1>0 && ((GenParticle*)branchParticle->At(genW1->D1))->PID == 13){
genmu1 = (GenParticle*)branchParticle->At(genW1->D1);
gennu1 = (GenParticle*)branchParticle->At(genW1->D2);
Wtomu1nu1 = true;
}else if (genW1->D2 >0 && ((GenParticle*)branchParticle->At(genW1->D2))->PID == 13){
genmu1 = (GenParticle*)branchParticle->At(genW1->D2);
gennu1 = (GenParticle*)branchParticle->At(genW1->D1);
Wtomu1nu1 = true;
}
if (genW2->D1>0 && ((GenParticle*)branchParticle->At(genW2->D1))->PID == -13){
genmu2 = (GenParticle*)branchParticle->At(genW2->D1);
gennu2 = (GenParticle*)branchParticle->At(genW2->D2);
Wtomu2nu2 = true;
} else if (genW2->D1>0 && ((GenParticle*)branchParticle->At(genW2->D2))->PID == -13){
genmu2 = (GenParticle*)branchParticle->At(genW2->D2);
gennu2 = (GenParticle*)branchParticle->At(genW2->D1);
Wtomu2nu2 = true;
}
}
if (Wtomu1nu1){
getFinalState(genmu1, branchParticle);
getFinalState(gennu1, branchParticle);
mu1_px = genmu1->Px; mu1_py = genmu1->Py; mu1_pz = genmu1->Pz; mu1_energy = genmu1->E;
mu1_eta = genmu1->Eta; mu1_phi = genmu1->Phi; mu1_pt = genmu1->PT;
nu1_px = gennu1->Px; nu1_py = gennu1->Py; nu1_pz = gennu1->Pz; nu1_energy = gennu1->E;
nu1_eta = gennu1->Eta; nu1_phi = gennu1->Phi; nu1_pt = gennu1->PT;
//cout << "mu1 from W "; printGenParticle(genmu1);
}
if (Wtomu2nu2){
getFinalState(genmu2, branchParticle);
getFinalState(gennu2, branchParticle);
mu2_px = genmu2->Px; mu2_py = genmu2->Py; mu2_pz = genmu2->Pz; mu2_energy = genmu2->E;
mu2_eta = genmu2->Eta; mu2_phi = genmu2->Phi; mu2_pt = genmu2->PT;
nu2_px = gennu2->Px; nu2_py = gennu2->Py; nu2_pz = gennu2->Pz; nu2_energy = gennu2->E;
nu2_eta = gennu2->Eta; nu2_phi = gennu2->Phi; nu2_pt = gennu2->PT;
//cout << "mu2 from W "; printGenParticle(genmu2);
}
//loop all Gen jets
for (i =0; i< branchGenJet->GetEntries(); i++)
{
genjet = (Jet*) branchGenJet->At(i);
if (genjet->PT < bjetsPt_ || abs(genjet->Eta)> bjetsEta_) continue;
TLorentzVector genjet_p4 = genjet->P4();
if (htobb && genjet_p4.DeltaR(genb1->P4()) < dR_genb1jet && genjet_p4.DeltaR(genb1->P4())<jetsDeltaR_) {
dR_genb1jet = genjet_p4.DeltaR(genb1->P4());
genb1jet_px = genjet_p4.Px(); genb1jet_py = genjet_p4.Py(); genb1jet_pz=genjet_p4.Pz(); genb1jet_energy = genjet_p4.Energy();
genb1jet_eta = genjet_p4.Eta(); genb1jet_phi = genjet_p4.Phi();
genb1jet_pt = genjet_p4.Pt();
hasgenb1jet = true;
genb1jet = genjet;
//cout <<"genb1jet pt "<< genb1jet_pt << endl;
}
if (htobb && genjet_p4.DeltaR(genb2->P4()) < dR_genb2jet && genjet_p4.DeltaR(genb2->P4()) < jetsDeltaR_){
dR_genb2jet = genjet_p4.DeltaR(genb2->P4());
genb2jet_px = genjet_p4.Px(); genb2jet_py = genjet_p4.Py(); genb2jet_pz=genjet_p4.Pz(); genb2jet_energy = genjet_p4.Energy();
genb2jet_eta = genjet_p4.Eta(); genb2jet_phi = genjet_p4.Phi();
genb2jet_pt = genjet_p4.Pt();
hasgenb2jet = true;
genb2jet = genjet;
//cout <<"genb2jet pt "<< genb2jet_pt << endl;
}
}*/
//loop all reco jets
for (i =0; i< branchJet->GetEntries(); i++)
{
jet = (Jet*) branchJet->At(i);
if (jet->PT < jetsPt_ || abs(jet->Eta)> jetsEta_) continue;
totjets_lorentz +=jet->P4();
if (jet->PT < bjetsPt_ || abs(jet->Eta)> bjetsEta_) continue;
TLorentzVector jet_p4 = jet->P4();
//how to whether it a bjet, b1jet has larger PT
if (jet->BTag and !hasb1jet and !hasb2jet) {
b1jet = jet;
b1jet_p4 = jet_p4;
b1jet_px = jet_p4.Px(); b1jet_py = jet_p4.Py(); b1jet_pz=jet_p4.Pz(); b1jet_energy = jet_p4.Energy();
b1jet_eta = jet_p4.Eta(); b1jet_phi = jet_p4.Phi();
b1jet_pt = jet_p4.Pt();
//cout <<"b1jet pt "<< b1jet_pt << endl;
hasb1jet = true;
}
else if (jet->BTag and hasb1jet and ((!hasb2jet and jet->PT<b1jet->PT) || (hasb2jet and jet->PT>b2jet->PT))){
b2jet = jet;
b2jet_p4 = jet_p4;
b2jet_px = jet_p4.Px(); b2jet_py = jet_p4.Py(); b2jet_pz=jet_p4.Pz(); b2jet_energy = jet_p4.Energy();
b2jet_eta = jet_p4.Eta(); b2jet_phi = jet_p4.Phi();
b2jet_pt = jet_p4.Pt();
hasb2jet = true;
//cout <<"b2jet pt "<< b2jet_pt << endl;
}
else if (jet->BTag and hasb1jet and jet->PT>b1jet->PT){
b2jet = b1jet;
b2jet_p4 = b1jet->P4();
b2jet_px = b2jet_p4.Px(); b2jet_py = b2jet_p4.Py(); b2jet_pz=b2jet_p4.Pz(); b2jet_energy = b2jet_p4.Energy();
b2jet_eta = b2jet_p4.Eta(); b2jet_phi = b2jet_p4.Phi();
b2jet_pt = b2jet_p4.Pt();
b1jet = jet;
b1jet_p4 = jet_p4;
b1jet_px = jet_p4.Px(); b1jet_py = jet_p4.Py(); b1jet_pz=jet_p4.Pz(); b1jet_energy = jet_p4.Energy();
b1jet_eta = jet_p4.Eta(); b1jet_phi = jet_p4.Phi();
b1jet_pt = jet_p4.Pt();
}
}
// b1jet should be different from b2jet
if (hasb1jet && hasb2jet && b1jet == b2jet){
hasb1jet = false;
hasb2jet = false;
}
else if (hasb1jet && hasb2jet){
cout <<" b1jet Pt " << b1jet->PT <<" b2jet Pt " << b2jet->PT << endl;
// TLorentzVector htobb_jets = b1jet->P4()+b2jet->P4();
//cout <<" htobb_jet " << htobb_jets.M(); htobb_jets.Print();
}
// Analyse missing ET, generator level
/*
if(branchGenMissingET->GetEntriesFast() > 0)
{
genMet = (MissingET*) branchGenMissingET->At(0);
genmet = genMet->MET;
genmet_phi = genMet->Phi;
genmet_px = genMet->P4().Px();
genmet_py = genMet->P4().Py();
if (genmet > metPt_) hasGenMET = true;
//cout <<" has genMET " << genmet << endl;
}*/
//apply muon cuts on muons
// Analyse missing ET, reco level
if(branchMissingET->GetEntriesFast() > 0)
{
Met = (MissingET*) branchMissingET->At(0);
met = Met->MET;
met_phi = Met->Phi;
met_px = Met->P4().Px();
met_py = Met->P4().Py();
if (met > metPt_) hasMET = true;
}
if (hasMET) cout <<" has MET " << met << endl;
//apply muon cuts on muons
//Loop over all Muon(before Isolation) in event
//how to check whether deltaR matching and matching genparticle has same performance??
/*
for(i = 0; i < branchMuonBeforeIso->GetEntriesFast(); ++i)
{
muon = (Muon*) branchMuonBeforeIso->At(i);
TLorentzVector muon_p4 = muon->P4();
//
//particle = (GenParticle*) muon->Particle.GetObject();
// printGenParticle(particle);
// how to choose muon if more than one muon could pass acceptance cuts
if (muon->Charge<0 and abs(muon->Eta)<muonsEta_ and muon->PT >= muonPt1_) {
muon1_beforeIso = muon;
hasMuon1_beforeIso = true;
}
else if(muon->Charge>0 and abs(muon->Eta)<muonsEta_ and muon->PT >= muonPt1_) {
muon2_beforeIso = muon;
hasMuon2_beforeIso = true;
}
if (hasMuon1_beforeIso) std::cout <<" has reco Muon1 before Iso " << std::endl;
if (hasMuon2_beforeIso) std::cout <<" has reco Muon2 before Iso " << std::endl;
}
if (hasMuon1_beforeIso){
Muon1_beforeIso_px = muon1_beforeIso->P4().Px(); Muon1_beforeIso_py = muon1_beforeIso->P4().Py(); Muon1_beforeIso_pz = muon1_beforeIso->P4().Pz(); Muon1_beforeIso_energy = muon1_beforeIso->P4().E();
Muon1_beforeIso_eta = muon1_beforeIso->P4().Eta(); Muon1_beforeIso_phi = muon1_beforeIso->P4().Phi();
Muon1_pt = muon1_beforeIso->PT;
}
if (hasMuon2_beforeIso){
Muon2_beforeIso_px = muon2_beforeIso->P4().Px(); Muon2_beforeIso_py = muon2_beforeIso->P4().Py(); Muon2_beforeIso_pz = muon2_beforeIso->P4().Pz(); Muon2_beforeIso_energy = muon2_beforeIso->P4().E();
Muon2_beforeIso_eta = muon2_beforeIso->P4().Eta(); Muon2_beforeIso_phi = muon2_beforeIso->P4().Phi();
Muon2_pt = muon2_beforeIso->PT;
}
*/
// Loop over all Muon in event, reco muon
for(i = 0; i < branchMuon->GetEntriesFast(); ++i)
{
muon = (Muon*) branchMuon->At(i);
TLorentzVector muon_p4 = muon->P4();
// printGenParticle(particle);
//if (hasMuon1_beforeIso and muon->Eta == muon1_beforeIso->Eta and muon->Phi == muon1_beforeIso->Phi) Muon1_beforeIso_passIso = true;
//if (hasMuon2_beforeIso and muon->Eta == muon2_beforeIso->Eta and muon->Phi == muon2_beforeIso->Phi) Muon2_beforeIso_passIso = true;
//check charge and deltaR, genmu1: charge<0, genmu2: charge>0
if (muon->Charge<0 and abs(muon->Eta)<muonsEta_ and muon->PT >= muonPt1_) {
muon1 = muon;
hasMuon1 = true;
}
else if(muon->Charge>0 and abs(muon->Eta)<muonsEta_ and muon->PT >= muonPt1_) {
muon2 = muon;
hasMuon2 = true;
}
if (hasMuon1) std::cout <<" has reco Muon1 " << std::endl;
if (hasMuon2) std::cout <<" has reco Muon2 " << std::endl;
//cout <<" muon eta " << muon->Eta << " phi " << muon->Phi << " Pt "<< muon->PT << endl;
}
if (hasMuon1){
Muon1_p4 = muon1->P4();
Muon1_px = muon1->P4().Px(); Muon1_py = muon1->P4().Py(); Muon1_pz = muon1->P4().Pz(); Muon1_energy = muon1->P4().E();
Muon1_eta = muon1->P4().Eta(); Muon1_phi = muon1->P4().Phi(); Muon1_pt = muon1->PT;
}
if (hasMuon2){
Muon2_p4 = muon2->P4();
Muon2_px = muon2->P4().Px(); Muon2_py = muon2->P4().Py(); Muon2_pz = muon2->P4().Pz(); Muon2_energy = muon2->P4().E();
Muon2_eta = muon2->P4().Eta(); Muon2_phi = muon2->P4().Phi(); Muon2_pt = muon2->PT;
}
if (hasMuon1 && hasMuon2){
if (((muon1->PT > muonPt1_ && muon2->PT > muonPt2_) || (muon1->PT > muonPt2_ && muon2->PT > muonPt1_))
&& fabs(muon1->Eta)<muonsEta_ && fabs(muon2->Eta)< muonsEta_) hastwomuons =true;
}
// Loop over all electrons in event
// do similar thing for electron when electrons are also taken as final state
for(i = 0; i < branchElectron->GetEntriesFast(); ++i)
{
electron = (Electron*) branchElectron->At(i);
//particle = (GenParticle*) electron->Particle.GetObject();
cout <<" electron "; printSortableObject<Electron>(electron);
}
// Loop over all photons in event
for(i = 0; i < branchPhoton->GetEntriesFast(); ++i)
{
photon = (Photon*) branchPhoton->At(i);
// skip photons with references to multiple particles
if(photon->Particles.GetEntriesFast() != 1) continue;
//particle = (GenParticle*) photon->Particles.At(0);
cout <<" photon "; printSortableObject<Photon>(photon);
}
if (hasb1jet and hasb2jet and hasMuon1 and hasMuon2){
dR_b1l1 = b1jet_p4.DeltaR(Muon1_p4);
dR_b1l2 = b1jet_p4.DeltaR(Muon2_p4);
dR_b2l1 = b2jet_p4.DeltaR(Muon1_p4);
dR_b2l2 = b2jet_p4.DeltaR(Muon2_p4);
dR_b1b2 = b1jet_p4.DeltaR(b2jet_p4);
dR_l1l2 = Muon1_p4.DeltaR(Muon2_p4);
TLorentzVector ll_p4 = Muon1_p4+Muon2_p4;
TLorentzVector bjets_p4 = b1jet_p4+b2jet_p4;
mass_l1l2 = ll_p4.M();
mass_b1b2 = bjets_p4.M();
if (dR_b1l1>jetleptonDeltaR_ and dR_b1l2>jetleptonDeltaR_ and dR_b2l1>jetleptonDeltaR_ and dR_b2l2>jetleptonDeltaR_) hasdRljet =true;
}
// Loop over all tracks in event
/*
for(i = 0; i < branchTrack->GetEntriesFast(); ++i)
{
track = (Track*) branchTrack->At(i);
particle = (GenParticle*) track->Particle.GetObject();
cout <<" Track "; printGenParticle(particle);
}*/
// calculate the DeltaR between bjet and lepton
if (runMMC_ and hasdRljet){
TLorentzVector bjets_lorentz=b1jet->P4()+b2jet->P4();
cout <<" m_{bjets} " << bjets_lorentz.M(); bjets_lorentz.Print();
TLorentzVector met_lorentz = Met->P4();
bool weightfromonshellnupt_func = false;
bool weightfromonshellnupt_hist = true;
bool weightfromonoffshellWmass_hist=true;
int iterations = 100000;
std::string RefPDFfile("MMCRefPDF.ROOT");
bool useMET = true;
bool onshellMarker_ = -1;
// rescale bjets in MMC?????
//MMC *thismmc = new MMC();
TLorentzVector null_lorentz = TLorentzVector();
MMC *thismmc = new MMC(Muon1_p4, Muon2_p4, bjets_lorentz, totjets_lorentz,
met_lorentz, null_lorentz, null_lorentz, null_lorentz,
null_lorentz, onshellMarker_,// only for simulation
false, entry, weightfromonshellnupt_func, weightfromonshellnupt_hist, weightfromonoffshellWmass_hist,
iterations, RefPDFfile, useMET);
thismmc->runMMC();
TTree *mmctree = (thismmc->getMMCTree())->CloneTree();
std::cout <<"MMCTree entries " << (thismmc->getMMCTree())->GetEntries() << std::endl;
std::cout <<"testtree entries " << mmctree->GetEntries()<<" title "<< mmctree->GetTitle() << std::endl;
//esttree->SetDirectory((TDirectory*)MMCfile);
//MMCfile->WriteObject(mmctree,mmctree->GetTitle());
delete thismmc;
}
//fill branches
if (hasb1jet or hasb2jet or hasMuon1 or hasMuon2) evtree->Fill();
}
}
