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(); } }