void cVNSIChannelFilter::SortChannels() { #if VDRVERSNUM >= 20301 LOCK_CHANNELS_WRITE; for (cChannel *channel = Channels->First(); channel; channel = Channels->Next(channel)) #else Channels.IncBeingEdited(); Channels.Lock(true); for (cChannel *channel = Channels.First(); channel; channel = Channels.Next(channel)) #endif { if(!PassFilter(*channel)) { #if VDRVERSNUM >= 20301 for (cChannel *whitechan = Channels->Next(channel); whitechan; whitechan = Channels->Next(whitechan)) #else for (cChannel *whitechan = Channels.Next(channel); whitechan; whitechan = Channels.Next(whitechan)) #endif { if(PassFilter(*whitechan)) { #if VDRVERSNUM >= 20301 Channels->Move(whitechan, channel); #else Channels.Move(whitechan, channel); #endif channel = whitechan; break; } } } } #if VDRVERSNUM >= 20301 Channels->SetModifiedByUser(); #else Channels.SetModified(true); Channels.Unlock(); Channels.DecBeingEdited(); #endif }
int filter(TString inputDir, long n_evt=100,bool is11=false,bool isFR=false) { long TotalEvents=n_evt; //options bool is2011=is11; int N_ALL=4; int N_ELMU=-3; if(isFR){ N_ALL=-4; N_ELMU=3; } double cut_mu_pt=9.0; double cut_mu_eta=2.4; double cut_el_pt=9.0; double cut_el_eta=2.5; double cut_tau_pt=19.0; double cut_tau_eta=2.3; if(isFR) cut_tau_pt=0.0; double cut_dR=-0.09; double lepton_mass_min=50.0; double lepton_mass_max=150.0; std::string doubEle="HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v"; std::string doubEle2="HLT_Ele17_CaloIdL_CaloIsoVL_Ele8_CaloIdL_CaloIsoVL_v"; std::string doubMu="HLT_Mu17_Mu8_v"; std::string doubMu2="HLT_Mu17_TkMu8_v"; // "HLT_Mu13_Mu8_v" in 2011 if(is2011) doubMu2="HLT_Mu13_Mu8_v"; std::string doubMu3="HLT_DoubleMu7_v"; bool debug = false; TChain *chain = new TChain("t"); chain->Add(inputDir+"*root*"); //////////////////////// end of modular part //////////////////////////////////////// /////////////////////////COMMON part ////////////////////////////////////////// myevent* in = new myevent(); chain->SetBranchAddress("myevent",&in); long MaxEvents = chain->GetEntries(); if(TotalEvents > MaxEvents || TotalEvents < 0) TotalEvents=MaxEvents; std::cout << "There are " << MaxEvents << " entries." << std::endl; //bookkeeping ofstream lumi; long current_run=-1; long current_lumi=-1; long m_allEvents=0; lumi.open("lumi.csv"); //output definition TFile *newFile = new TFile("output.root","recreate"); TChain *newchain = (TChain*)chain->CloneTree(0); TTree *tree = newchain->GetTree(); for(uint i =0; i < TotalEvents; i++) { chain->GetEntry(i); m_allEvents++; if(debug) std::cout << "Processing entry " << i << " event: " << in->eventNumber << std::endl; if(i%1000==0)std::cout << "Analyzing entry no. " << i << std::endl; // storing lumis if(in->runNumber!=current_run || in->lumiNumber!=current_lumi){ lumi << in->runNumber << " " << in->lumiNumber << std::endl; current_run=in->runNumber; current_lumi=in->lumiNumber; } if(PassFilter(in, debug, doubEle, doubEle2, doubMu, doubMu2, doubMu3, is2011, N_ALL, N_ELMU, cut_mu_pt, cut_mu_eta, cut_el_pt, cut_el_eta, cut_tau_pt, cut_tau_eta, cut_dR, lepton_mass_min, lepton_mass_max) ) tree->Fill(); } newFile->cd(); newFile->Write(); newFile->Close(); ofstream log1; log1.open("total.txt"); log1 << m_allEvents << std::endl; log1.close(); return 0; }
void placeholder::Loop() { //=================================================================================================== // MAKE TREE FOR PLACEHOLDER SIGNAL/BG TYPE AND DECLARE VARIABLES //=================================================================================================== // Update output file TFile * file1 = new TFile("placeholder.root","RECREATE"); // create tree for the signal or background type TTree *tree=new TTree("PhysicalVariables","PhysicalVariables"); //***************************************************************** // MUON AND CALOJET/CALOMET VARIABLES BELOW //***************************************************************** // Particle Counts BRANCH(MuonCount); BRANCH(EleCount); BRANCH(PFJetCount); BRANCH(BpfJetCount); BRANCH(GlobalMuonCount); BRANCH(TrackerMuonCount); // Leading muon 1 BRANCH(TrkD0_muon1); BRANCH(NHits_muon1); BRANCH(TrkDZ_muon1); BRANCH(ChiSq_muon1); BRANCH(TrkIso_muon1); BRANCH(EcalIso_muon1); BRANCH(HcalIso_muon1); BRANCH(RelIso_muon1); BRANCH(Phi_muon1); BRANCH(Eta_muon1); BRANCH(Pt_muon1); BRANCH(Charge_muon1); BRANCH(QOverPError_muon1); BRANCH(PhiError_muon1); BRANCH(EtaError_muon1); BRANCH(PtError_muon1); // Leading muon 2 BRANCH(TrkD0_muon2); BRANCH(NHits_muon2); BRANCH(TrkDZ_muon2); BRANCH(ChiSq_muon2); BRANCH(TrkIso_muon2); BRANCH(EcalIso_muon2); BRANCH(HcalIso_muon2); BRANCH(RelIso_muon2); BRANCH(Phi_muon2); BRANCH(Eta_muon2); BRANCH(Pt_muon2); BRANCH(Charge_muon2); BRANCH(QOverPError_muon2); BRANCH(PhiError_muon2); BRANCH(EtaError_muon2); BRANCH(PtError_muon2); // PFJet 1 BRANCH(Phi_pfjet1); BRANCH(Eta_pfjet1); BRANCH(Pt_pfjet1); BRANCH(BDisc_pfjet1); BRANCH(PFJetNeutralMultiplicity_pfjet1); BRANCH(PFJetNeutralHadronEnergyFraction_pfjet1); BRANCH(PFJetNeutralEmEnergyFraction_pfjet1); BRANCH(PFJetChargedMultiplicity_pfjet1); BRANCH(PFJetChargedHadronEnergyFraction_pfjet1); BRANCH(PFJetChargedEmEnergyFraction_pfjet1); // PFJet 2 BRANCH(Phi_pfjet2); BRANCH(Eta_pfjet2); BRANCH(Pt_pfjet2); BRANCH(BDisc_pfjet2); BRANCH(PFJetNeutralMultiplicity_pfjet2); BRANCH(PFJetNeutralHadronEnergyFraction_pfjet2); BRANCH(PFJetNeutralEmEnergyFraction_pfjet2); BRANCH(PFJetChargedMultiplicity_pfjet2); BRANCH(PFJetChargedHadronEnergyFraction_pfjet2); BRANCH(PFJetChargedEmEnergyFraction_pfjet2); // Electron (If any) BRANCH(Pt_ele1); // Event Information BRANCH(run_number); BRANCH(event_number); BRANCH(bx); BRANCH(xsection); BRANCH(weight); BRANCH(Events_AfterLJ); BRANCH(Events_Orig); BRANCH(N_Vertices); // PFMET BRANCH(MET_pf); BRANCH(Phi_MET_pf); // Delta Phi Variables BRANCH(deltaPhi_muon1muon2); BRANCH(deltaPhi_pfjet1pfjet2); BRANCH(deltaPhi_muon1pfMET); BRANCH(deltaPhi_muon2pfMET); BRANCH(deltaPhi_pfjet1pfMET); BRANCH(deltaPhi_pfjet2pfMET); BRANCH(deltaPhi_muon1pfjet1); BRANCH(deltaPhi_muon1pfjet2); BRANCH(deltaPhi_muon2pfjet1); BRANCH(deltaPhi_muon2pfjet2); // Delta R Variables BRANCH(deltaR_muon1muon2); BRANCH(deltaR_pfjet1pfjet2); BRANCH(deltaR_muon1pfjet1); BRANCH(deltaR_muon1pfjet2); BRANCH(deltaR_muon2pfjet1); BRANCH(deltaR_muon2pfjet2); BRANCH(deltaR_muon1closestPFJet); // Mass Combinations BRANCH(M_muon1muon2); BRANCH(M_pfjet1pfjet2); BRANCH(M_muon1pfjet1); BRANCH(M_muon1pfjet2); BRANCH(M_muon2pfjet1); BRANCH(M_muon2pfjet2); BRANCH(M_muon1muon2pfjet1pfjet2); BRANCH(M_bestmupfjet1_mumu); BRANCH(M_bestmupfjet2_mumu); BRANCH(M_bestmupfjet_munu); // Transverse Mass Combinations BRANCH(MT_muon1pfMET); BRANCH(MT_pfjet1pfMET); BRANCH(MT_pfjet2pfMET); BRANCH(MT_muon1pfjet1); BRANCH(MT_muon1pfjet2); BRANCH(MT_muon2pfjet1); BRANCH(MT_muon2pfjet2); // ST Variables BRANCH(ST_pf_mumu); BRANCH(ST_pf_munu); // Other Variables BRANCH(minval_muon1pfMET); BRANCH(Pt_Z); BRANCH(Pt_W); BRANCH(Phi_Z); BRANCH(Phi_W); BRANCH(N_PileUpInteractions); // Generator Level Variables BRANCH(Pt_genjet1); BRANCH(Pt_genjet2); BRANCH(Pt_genmuon1); BRANCH(Pt_genmuon2); BRANCH(Phi_genmuon1); BRANCH(Phi_genmuon2); BRANCH(Eta_genmuon1); BRANCH(Eta_genmuon2); BRANCH(Pt_genMET); BRANCH(Phi_genMET); BRANCH(Eta_genMET); BRANCH(Pt_genneutrino); BRANCH(Phi_genneutrino); BRANCH(Eta_genneutrino); BRANCH(genWTM); BRANCH(Pt_Z_gen); BRANCH(Pt_W_gen); BRANCH(Phi_Z_gen); BRANCH(Phi_W_gen); // Recoil variables BRANCH(U1_Z_gen); BRANCH(U2_Z_gen); BRANCH(U1_W_gen); BRANCH(U2_W_gen); BRANCH(U1_Z); BRANCH(U2_Z); BRANCH(U1_W); BRANCH(U2_W); BRANCH(UdotMu); BRANCH(UdotMu_overmu); //=================================================================================================== //=================================================================================================== //=================================================================================================== // SETUP WITH SOME TEMPLATE INPUTS AND THRESHOLDS //=================================================================================================== // "desired_luminosity" is a PlaceHolder that gets replaced from the python template replicator Double_t lumi=desired_luminosity; // PlaceHolder, values stored in bookkeeping/NTupleInfo.csv Events_Orig = Numberofevents; // Another placeHolder. Needed because recoil corrections only get applied to W MC. bool IsW = IsItWMC; bool IsSpring11ZAlpgen = IsItSpring11ZAlpgen; xsection = crosssection; // Another PlaceHolder for the cross sections in bookkeeping/NTupleInfo.csv //=================================================================================================== //=================================================================================================== //=================================================================================================== // LOOP OVER ENTRIES AND MAKE MAIN CALCULATIONS //=================================================================================================== if (fChain == 0) return; //check for correctly assigned chain from h file Long64_t nentries = fChain->GetEntriesFast(); Long64_t nbytes = 0, nb = 0; //nentries=10000; /// TEST>>>>>> COMMENT THIS ALWAYS for (Long64_t jentry=0; jentry<nentries;jentry++) { Long64_t ientry = LoadTree(jentry); if (ientry < 0) break; nb = fChain->GetEntry(jentry); nbytes += nb; // if (jentry>1000) break; // Important Event Informations run_number = run; event_number = event; bx = bunch; weight = lumi*xsection/Events_Orig; //======================== Weight Fix for Spring 11 Z Alpgen ===============// Double_t rescale = 1.0; for(unsigned int ip = 0; ip != GenParticlePdgId->size(); ++ip) { int pdgId = GenParticlePdgId->at(ip); int motherIndex = GenParticleMotherIndex->at(ip); if (motherIndex >= 0) { if (abs(GenParticlePdgId->at(motherIndex) ) == 23) { int lepton = 999; if (abs(pdgId) == 11) lepton = 11; if (abs(pdgId) == 13) lepton = 13; if (abs(pdgId) == 15) lepton = 15; if (IsSpring11ZAlpgen) { if (lepton == 999) rescale = 1.0; if (lepton == 11) rescale = electron_rescalevalue; if (lepton == 13) rescale = muon_rescalevalue; if (lepton == 15) rescale = tau_rescalevalue; weight = weight*rescale; } if (lepton <999) break; } } } //======================== HLT Conditions ================================// // if (run_number<1000) // { // if ( ((*HLTResults)[60] ==1) ||((*HLTResults)[0] ==1) ) precut_HLT=1.0; // else continue; // } // if ((run_number>1000)&&(run_number<146000)) // { // if ((*HLTResults)[60] ==1) precut_HLT=1.0; // else continue; // } // if ((run_number>146000)&&(run_number<147455)) // { // if ((*HLTResults)[61] ==1) precut_HLT=1.0; // else continue; // } // if (run_number>=147455) // { // if ((*HLTResults)[66] ==1) precut_HLT=1.0; // else continue; // } //======================== JSON Conditions ================================// if (isData) { bool KeepEvent = PassFilter(run, ls); if (!KeepEvent) continue; } //======================== Vertex Conditions ================================// if ( isBeamScraping ) continue; bool vtxFound = false; for(unsigned int ivtx = 0; ivtx != VertexZ->size(); ++ivtx) { if ( VertexIsFake->at(ivtx) == true ) continue; if ( VertexNDF->at(ivtx) <= 4.0 ) continue; if ( TMath::Abs(VertexZ->at(ivtx)) > 24.0 ) continue; if ( TMath::Abs(VertexRho->at(ivtx)) >= 2.0 ) continue; vtxFound = true; break; } if ( !vtxFound ) continue; N_Vertices = VertexZ->size(); if (!isData) N_PileUpInteractions = 1.0*PileUpInteractions; //======================== Electron Conditions ================================// vector<int> v_idx_ele_final; // check if there are electrons int nelectrons = 0; for(unsigned int iele = 0; iele < ElectronPt->size(); ++iele) { // if ( ElectronPt->at(iele) < 15.0 ) continue; if ( (ElectronPassID->at(iele) & 1 << 5 ) && ElectronOverlaps->at(iele) == 0 ) { ++nelectrons; v_idx_ele_final.push_back(iele); } } //======================== Muon Conditions ================================// vector<int> v_idx_muon_final; // container for muons vector<TLorentzVector> muons; int iMUON = -1; // select muons bool checkPT = true; // Pt requirement only on first muon at this stage for(unsigned int imuon = 0; imuon < MuonPt->size(); ++imuon) { float muonPt = MuonPt->at(imuon); float muonEta = MuonEta->at(imuon); if (checkPT && (muonPt < 30.0) ) continue; if ( fabs(muonEta) > 2.4 ) continue; bool PassVBTFLoose = MuonIsGlobal ->at(imuon) == 1 && MuonTrackerkIsoSumPT->at(imuon) < 3.0 && MuonTrkHits ->at(imuon) >= 11 ; bool PassVBTFTight = MuonIsTracker ->at(imuon) == 1 && fabs(MuonTrkD0 ->at(imuon)) < 0.2 && MuonGlobalChi2 ->at(imuon) < 10.0 && MuonPixelHitCount ->at(imuon) >=1 && MuonSegmentMatches->at(imuon) >=2 && MuonGlobalTrkValidHits->at(imuon)>=1 ; if ( ! (PassVBTFLoose && PassVBTFTight) ) continue; iMUON = imuon; TLorentzVector muon; muon.SetPtEtaPhiM( MuonPt -> at(imuon), MuonEta-> at(imuon), MuonPhi-> at(imuon), 0); muons.push_back(muon); checkPT=false; v_idx_muon_final.push_back(imuon); } // loop over muons MuonCount = 1.0*v_idx_muon_final.size(); if ( MuonCount < 1 ) continue; TLorentzVector muon = muons[0]; // SubRoutine for Muon Counts GlobalMuonCount = 0.0; TrackerMuonCount = 0.0; for(unsigned int imuon = 0; imuon < MuonPt->size(); ++imuon) { if (MuonIsGlobal ->at(imuon) == 1) GlobalMuonCount += 1.0; if (MuonIsTracker ->at(imuon) == 1) TrackerMuonCount += 1.0; } //======================== PFJet Conditions ================================// // Get Good Jets in general deltaR_muon1closestPFJet = 999.9; float deltaR_thisjet = 9999.9; vector<TLorentzVector> jets; vector<int> v_idx_pfjet_prefinal; vector<int> v_idx_pfjet_final_unseparated; vector<int> v_idx_pfjet_final; BpfJetCount = 0.0; // Initial Jet Quality Selection for(unsigned int ijet = 0; ijet < PFJetPt->size(); ++ijet) { double jetPt = PFJetPt -> at(ijet); double jetEta = PFJetEta -> at(ijet); if ( jetPt < 30.0 ) continue; if ( fabs(jetEta) > 3.0 ) continue; if (PFJetPassLooseID->at(ijet) != 1) continue; //if (PFJetPassTightID->at(ijet) != 1) continue; v_idx_pfjet_prefinal.push_back(ijet); } /// Filter out jets that are actually muons TLorentzVector thisjet, thismu; vector<int> jetstoremove; float thisdeltar = 0.0; float mindeltar = 99999; int minjet = 0; int muindex = 99; int jetindex = 99; // Get list of jets to throw out // for(unsigned int imu=0; imu<v_idx_muon_final.size(); imu++) // { // mindeltar = 999999; // muindex = v_idx_muon_final[imu]; // thismu.SetPtEtaPhiM(MuonPt->at(muindex),MuonEta->at(muindex),MuonPhi->at(muindex),0); // for(unsigned int ijet=0; ijet<v_idx_pfjet_prefinal.size(); ijet++) // { // jetindex = v_idx_pfjet_prefinal[ijet]; // thisjet.SetPtEtaPhiM((*PFJetPt)[jetindex],(*PFJetEta)[jetindex],(*PFJetPhi)[jetindex],0); // thisdeltar = thismu.DeltaR(thisjet); // if (thisdeltar < mindeltar) // { // mindeltar = thisdeltar; // minjet = ijet; // } // } // if (mindeltar<0.3) jetstoremove.push_back(minjet) ; // } for(unsigned int ijet=0; ijet<v_idx_pfjet_prefinal.size(); ijet++) { jetindex = v_idx_pfjet_prefinal[ijet]; thisjet.SetPtEtaPhiM((*PFJetPt)[jetindex],(*PFJetEta)[jetindex],(*PFJetPhi)[jetindex],0); for(unsigned int imu=0; imu<v_idx_muon_final.size(); imu++) { muindex = v_idx_muon_final[imu]; thismu.SetPtEtaPhiM(MuonPt->at(muindex),MuonEta->at(muindex),MuonPhi->at(muindex),0); thisdeltar = thismu.DeltaR(thisjet); if (thisdeltar < 0.3) { jetstoremove.push_back(jetindex); } } } jetindex = 99; int remjetindex = 99; // Eliminate bad jets from prefinal jet vector, save as final for(unsigned int ijet=0; ijet<v_idx_pfjet_prefinal.size(); ijet++) { int jetgood = 1; jetindex = v_idx_pfjet_prefinal[ijet]; for(unsigned int kjet=0; kjet<jetstoremove.size(); kjet++) { remjetindex = jetstoremove[kjet]; if (jetindex == remjetindex) jetgood=0; } if (jetgood ==1) v_idx_pfjet_final_unseparated.push_back(jetindex); } // Take filtered jets and eliminate those too close to the muon. save b variables jetindex = 99; for(unsigned int ijet=0; ijet<v_idx_pfjet_final_unseparated.size(); ijet++) { jetindex = v_idx_pfjet_final_unseparated[ijet]; double jetPt = PFJetPt -> at(jetindex); double jetEta = PFJetEta -> at(jetindex); TLorentzVector newjet; newjet.SetPtEtaPhiM(jetPt, jetEta, PFJetPhi->at(jetindex), 0); // require a separation between a muon and a jet deltaR_thisjet = newjet.DeltaR(muon); if ( deltaR_thisjet < deltaR_muon1closestPFJet) deltaR_muon1closestPFJet = deltaR_thisjet ; // if ( deltaR_thisjet < 0.5 ) continue; if ( PFJetTrackCountingHighEffBTag->at(jetindex) > 1.7 ) { BpfJetCount = BpfJetCount + 1.0; } // if we are here, the jet is good v_idx_pfjet_final.push_back(jetindex); } PFJetCount = 1.0*v_idx_pfjet_final.size(); if (PFJetCount <2) continue; //======================== Generator Level Module ================================// float piover2 = 3.1415926/2.0; TLorentzVector V_MetAddition; V_MetAddition.SetPtEtaPhiM(0.0,0.0,0.0,0.0); TLorentzVector UW_gen , BW_gen, v_GenNu, muon1test; BW_gen.SetPtEtaPhiM(0,0,0,0); UW_gen.SetPtEtaPhiM(0,0,0,0); v_GenNu.SetPtEtaPhiM(0,0,0,0), muon1test.SetPtEtaPhiM(0,0,0,0) ; // Generator Level Variables VRESET(Pt_genjet1); VRESET(Pt_genjet2); VRESET(Pt_genmuon1); VRESET(Pt_genmuon2); VRESET(Phi_genmuon1); VRESET(Phi_genmuon2); VRESET(Eta_genmuon1); VRESET(Eta_genmuon2); VRESET(Pt_genMET); VRESET(Phi_genMET); VRESET(Eta_genMET); VRESET(Pt_genneutrino); VRESET(Phi_genneutrino); VRESET(Eta_genneutrino); VRESET(genWTM); VRESET(Pt_Z_gen); VRESET(Pt_W_gen); VRESET(Phi_Z_gen); VRESET(Phi_W_gen); // Recoil variables VRESET(U1_Z_gen); VRESET(U2_Z_gen); VRESET(U1_W_gen); VRESET(U2_W_gen); /// Generator Addon if (!isData) { Pt_genjet1 = 0; Pt_genjet2 = 0; Pt_genmuon1 = 0; Pt_genmuon2 = 0; Phi_genmuon1 = 0; Eta_genmuon1 = 0; Phi_genmuon2 = 0; Eta_genmuon2 = 0; Pt_genMET = 0; Pt_genneutrino = 0; Eta_genneutrino = 0; Phi_genneutrino = 0; Phi_genMET = 0; Eta_genMET = 0; for(unsigned int ijet = 0; ijet < GenJetPt->size(); ++ijet) { if (ijet ==0) Pt_genjet1 = GenJetPt->at(ijet); if (ijet ==1) Pt_genjet2 = GenJetPt->at(ijet); } for(unsigned int ip = 0; ip != GenParticlePdgId->size(); ++ip) { int pdgId = GenParticlePdgId->at(ip); int motherIndex = GenParticleMotherIndex->at(ip); // ISR if ( motherIndex == -1 ) continue; int pdgIdMother = GenParticlePdgId->at(motherIndex); //muon // && TMath::Abs(pdgIdMother) == 23 ) { if ( TMath::Abs(pdgId) == 13 ) { // std::cout<<GenParticlePt -> at (ip)<<" "<<GenParticlePhi-> at (ip)<<std::endl; if (Pt_genmuon1==0) { Pt_genmuon1 = GenParticlePt -> at (ip); Phi_genmuon1 = GenParticlePhi-> at (ip); Eta_genmuon1 = GenParticleEta-> at (ip); } if (Pt_genmuon1>0) { Pt_genmuon2 = GenParticlePt -> at (ip); Phi_genmuon2 = GenParticlePhi-> at (ip); Eta_genmuon2 = GenParticleEta-> at (ip); } } // Muon Neutrino if ( TMath::Abs(pdgId) == 14 ) { if (GenParticlePt->at(ip) > Pt_genneutrino) { Pt_genneutrino = GenParticlePt -> at (ip); Phi_genneutrino = GenParticlePhi-> at (ip); Eta_genneutrino = GenParticleEta-> at (ip); } } } Pt_genMET = GenMETTrue->at(0); Phi_genMET = GenMETPhiTrue->at(0); genWTM = 0.0; genWTM = TMass(Pt_genmuon1,Pt_genMET, fabs(Phi_genmuon1 - Phi_genMET) ); // Set the recoil variables U1_Z_gen = 990.0; U2_Z_gen = 990.0; U1_W_gen = 990.0; U2_W_gen = 990.0; TLorentzVector v_GenMuon1, v_GenMuon2, v_GenMet; v_GenMuon1.SetPtEtaPhiM(Pt_genmuon1,Eta_genmuon1,Phi_genmuon1,0); v_GenMuon2.SetPtEtaPhiM(Pt_genmuon2,Eta_genmuon2,Phi_genmuon2,0); v_GenNu.SetPtEtaPhiM( Pt_genneutrino ,Eta_genneutrino,Phi_genneutrino ,0); v_GenMet.SetPtEtaPhiM ( Pt_genMET, 0, Phi_genMET,0 ); Pt_Z_gen = (v_GenMuon1 + v_GenMuon2).Pt(); Phi_Z_gen = (v_GenMuon1 + v_GenMuon2).Phi(); TLorentzVector UZ_gen = -(v_GenMet + v_GenMuon1 + v_GenMuon2); TLorentzVector BZ_gen = (v_GenMuon1+v_GenMuon2 ); U1_Z_gen = (UZ_gen.Pt()) * (cos(UZ_gen.DeltaPhi(BZ_gen))) ; U2_Z_gen = (UZ_gen.Pt()) * (sin(UZ_gen.DeltaPhi(BZ_gen))) ; TLorentzVector pfMETtest; pfMETtest.SetPtEtaPhiM(PFMET->at(0),0.0,PFMETPhi->at(0),0.0); muon1test.SetPtEtaPhiM(MuonPt->at(v_idx_muon_final[0]),MuonEta->at(v_idx_muon_final[0]),MuonPhi->at(v_idx_muon_final[0]),0.0); Pt_W_gen = (muon1test + v_GenNu).Pt(); Phi_W_gen = (muon1test + v_GenNu).Phi(); UW_gen = -(pfMETtest + muon1test ); BW_gen = (muon1test +v_GenNu); U1_W_gen = (UW_gen.Pt()) * (cos(UW_gen.DeltaPhi(BW_gen))) ; U2_W_gen = (UW_gen.Pt()) * (sin(UW_gen.DeltaPhi(BW_gen))) ; if (IsW && DoRecoilCorrections) { float U1Phi = - BW_gen.Phi(); float U2Phi = BW_gen.Phi() + piover2; if ((BW_gen.DeltaPhi(UW_gen)) < 0) U2Phi = BW_gen.Phi() - piover2; float U1Prime = F_U1Prime(Pt_W_gen); float U2Prime = F_U2Prime(Pt_W_gen); TLorentzVector V_UPrime, V_U1Prime, V_U2Prime, V_MetPrime; V_U1Prime.SetPtEtaPhiM(U1Prime,0,U1Phi,0); V_U2Prime.SetPtEtaPhiM(U2Prime,0,U2Phi,0); V_UPrime = V_U1Prime + V_U2Prime; V_MetPrime = -(v_GenMuon1+ V_UPrime); V_MetAddition.SetPtEtaPhiM(V_MetPrime.Pt(),0,V_MetPrime.Phi(),0); V_MetAddition = V_MetAddition - v_GenMet; } } //======================== Set variables to zero ================================// // Leading muon 1 VRESET(TrkD0_muon1); VRESET(NHits_muon1); VRESET(TrkDZ_muon1); VRESET(ChiSq_muon1); VRESET(TrkIso_muon1); VRESET(EcalIso_muon1); VRESET(HcalIso_muon1); VRESET(RelIso_muon1); VRESET(Phi_muon1); VRESET(Eta_muon1); VRESET(Pt_muon1); VRESET(Charge_muon1); VRESET(QOverPError_muon1); VRESET(PhiError_muon1); VRESET(EtaError_muon1); VRESET(PtError_muon1); // Leading muon 2 VRESET(TrkD0_muon2); VRESET(NHits_muon2); VRESET(TrkDZ_muon2); VRESET(ChiSq_muon2); VRESET(TrkIso_muon2); VRESET(EcalIso_muon2); VRESET(HcalIso_muon2); VRESET(RelIso_muon2); VRESET(Phi_muon2); VRESET(Eta_muon2); VRESET(Pt_muon2); VRESET(Charge_muon2); VRESET(QOverPError_muon2); VRESET(PhiError_muon2); VRESET(EtaError_muon2); VRESET(PtError_muon2); // PFJet 1 VRESET(Phi_pfjet1); VRESET(Eta_pfjet1); VRESET(Pt_pfjet1); VRESET(BDisc_pfjet1); VRESET(PFJetNeutralMultiplicity_pfjet1); VRESET(PFJetNeutralHadronEnergyFraction_pfjet1); VRESET(PFJetNeutralEmEnergyFraction_pfjet1); VRESET(PFJetChargedMultiplicity_pfjet1); VRESET(PFJetChargedHadronEnergyFraction_pfjet1); VRESET(PFJetChargedEmEnergyFraction_pfjet1); // PFJet 2 VRESET(Phi_pfjet2); VRESET(Eta_pfjet2); VRESET(Pt_pfjet2); VRESET(BDisc_pfjet2); VRESET(PFJetNeutralMultiplicity_pfjet2); VRESET(PFJetNeutralHadronEnergyFraction_pfjet2); VRESET(PFJetNeutralEmEnergyFraction_pfjet2); VRESET(PFJetChargedMultiplicity_pfjet2); VRESET(PFJetChargedHadronEnergyFraction_pfjet2); VRESET(PFJetChargedEmEnergyFraction_pfjet2); // Electron (If any) VRESET(Pt_ele1); // PFMET VRESET(MET_pf); VRESET(Phi_MET_pf); // Delta Phi Variables VRESET(deltaPhi_muon1muon2); VRESET(deltaPhi_pfjet1pfjet2); VRESET(deltaPhi_muon1pfMET); VRESET(deltaPhi_muon2pfMET); VRESET(deltaPhi_pfjet1pfMET); VRESET(deltaPhi_pfjet2pfMET); VRESET(deltaPhi_muon1pfjet1); VRESET(deltaPhi_muon1pfjet2); VRESET(deltaPhi_muon2pfjet1); VRESET(deltaPhi_muon2pfjet2); // Delta R Variables VRESET(deltaR_muon1muon2); VRESET(deltaR_pfjet1pfjet2); VRESET(deltaR_muon1pfjet1); VRESET(deltaR_muon1pfjet2); VRESET(deltaR_muon2pfjet1); VRESET(deltaR_muon2pfjet2); VRESET(deltaR_muon1closestPFJet); // Mass Combinations VRESET(M_muon1muon2); VRESET(M_pfjet1pfjet2); VRESET(M_muon1pfjet1); VRESET(M_muon1pfjet2); VRESET(M_muon2pfjet1); VRESET(M_muon2pfjet2); VRESET(M_muon1muon2pfjet1pfjet2); VRESET(M_bestmupfjet1_mumu); VRESET(M_bestmupfjet2_mumu); VRESET(M_bestmupfjet_munu); // Transverse Mass Combinations VRESET(MT_muon1pfMET); VRESET(MT_pfjet1pfMET); VRESET(MT_pfjet2pfMET); VRESET(MT_muon1pfjet1); VRESET(MT_muon1pfjet2); VRESET(MT_muon1pfjet2); VRESET(MT_muon2pfjet2); // ST Variables VRESET(ST_pf_mumu); VRESET(ST_pf_munu); // Other Variables VRESET(minval_muon1pfMET); VRESET(Pt_Z); VRESET(Pt_W); VRESET(Phi_Z); VRESET(Phi_W); // Recoil variables VRESET(U1_Z); VRESET(U2_Z); VRESET(U1_W); VRESET(U2_W); VRESET(UdotMu); VRESET(UdotMu_overmu); //=================================================================================================== // Run the Calculations of physical variables using selected particles. //=================================================================================================== // 4-Vectors for Particles TLorentzVector jet1, jet2, pfjet1, pfjet2, muon1,muon3, caloMET,muon2,pfMET,tcMET; //======================== MET Basics ================================// MET_pf = PFMET->at(0); pfMET.SetPtEtaPhiM(MET_pf,0.0,PFMETPhi->at(0),0.0); //======================== MET Recoil Correction ================================// // Recoil Corrections if (IsW && DoRecoilCorrections && true) { // Very careful calculation of the geometry of the recoil vectors. float U1Phi = BW_gen.Phi() + 2*piover2; if (U1Phi> (2*piover2)) U1Phi = U1Phi - 4*piover2; float check_phi_u1 = U1Phi; if (check_phi_u1<0) check_phi_u1 = check_phi_u1 + 4*piover2; float check_phi_w = BW_gen.Phi(); if (check_phi_w<0) check_phi_w = check_phi_w + 4*piover2; float check_phi_u = UW_gen.Phi(); if (check_phi_u<0) check_phi_u = check_phi_u + 4*piover2; float check_phi_u2 = 99; if ((check_phi_w<2*piover2)&&(check_phi_u>check_phi_w)) check_phi_u2 = check_phi_w + piover2; if ((check_phi_w<2*piover2)&&(check_phi_u<check_phi_w)) check_phi_u2 = check_phi_w - piover2; if ((check_phi_w>2*piover2)&&(check_phi_u>check_phi_w)) check_phi_u2 = check_phi_w + piover2; if ((check_phi_w>2*piover2)&&(check_phi_u<check_phi_w)&&(check_phi_u>(check_phi_w - 2*piover2))) check_phi_u2 = check_phi_w - piover2; if ((check_phi_w>2*piover2)&&(check_phi_u<check_phi_w)&&(check_phi_u<(check_phi_w - 2*piover2))) check_phi_u2 = check_phi_w + piover2; if (check_phi_u2 > 4*piover2) check_phi_u2 = check_phi_u2 - 4*piover2; // Get the new recoil vectors float U2Phi = check_phi_u2; float reco_Pt_W = (muon1test + v_GenNu).Pt(); float U1Prime = F_U1Prime(reco_Pt_W); float U2Prime = F_U2Prime(reco_Pt_W); // Change the MET vector based on the new recoil vectors TLorentzVector V_UPrime, V_U1Prime, V_U2Prime, V_MetPrime; V_U1Prime.SetPtEtaPhiM(U1Prime,0,U1Phi,0); V_U2Prime.SetPtEtaPhiM(U2Prime,0,U2Phi,0); V_UPrime = V_U1Prime + V_U2Prime; V_MetPrime = -(muon1test+ V_UPrime); pfMET.SetPtEtaPhiM(V_MetPrime.Pt(),0,V_MetPrime.Phi(),0); MET_pf = pfMET.Pt(); } //======================== Electrons? ================================// if (EleCount>=1) { Pt_ele1 = ElectronPt->at(v_idx_ele_final[0]); } //======================== At least 1 muon ================================// if (MuonCount>=1) { // Quality Variables TrkD0_muon1 = MuonTrkD0->at(v_idx_muon_final[0]); NHits_muon1 = MuonTrkHits ->at(v_idx_muon_final[0]); Charge_muon1 = MuonCharge->at(v_idx_muon_final[0]); RelIso_muon1 = MuonRelIso->at(v_idx_muon_final[0]); TrkDZ_muon1 = MuonTrkDz->at(v_idx_muon_final[0]); TrkIso_muon1 = MuonTrkIso->at(v_idx_muon_final[0]); EcalIso_muon1 = MuonEcalIso->at(v_idx_muon_final[0]); HcalIso_muon1 = MuonHcalIso->at(v_idx_muon_final[0]); ChiSq_muon1 = MuonGlobalChi2->at(v_idx_muon_final[0]); QOverPError_muon1 = MuonQOverPError->at(v_idx_muon_final[0]); PhiError_muon1 = MuonPhiError->at(v_idx_muon_final[0]); EtaError_muon1 = MuonEtaError->at(v_idx_muon_final[0]); PtError_muon1 = MuonPtError->at(v_idx_muon_final[0]); // muon Pt/Eta/Phi Pt_muon1 = MuonPt->at(v_idx_muon_final[0]); Phi_muon1 = MuonPhi->at(v_idx_muon_final[0]); Eta_muon1 = MuonEta->at(v_idx_muon_final[0]); // Other Variables muon1.SetPtEtaPhiM(Pt_muon1,Eta_muon1,Phi_muon1,0); deltaPhi_muon1pfMET = (pfMET.DeltaPhi(muon1)); MT_muon1pfMET = TMass(Pt_muon1,MET_pf,deltaPhi_muon1pfMET); minval_muon1pfMET = Pt_muon1; if (MET_pf < Pt_muon1) minval_muon1pfMET = MET_pf; // Recoil Stuff Pt_W = (muon1 + pfMET).Pt(); Phi_W = (muon1 + pfMET).Phi(); TLorentzVector UW = -(pfMET + muon1); TLorentzVector BW = (muon1+pfMET); U1_W = (UW.Pt()) * (cos(UW.DeltaPhi(BW))) ; U2_W = (UW.Pt()) * (sin(UW.DeltaPhi(BW))) ; UdotMu = Pt_muon1*UW.Pt()*cos(UW.DeltaPhi(muon1)); UdotMu_overmu = UW.Pt()*cos(UW.DeltaPhi(muon1)); } //======================== At least 2 muon ================================// if (MuonCount>=2) { // Quality Variables TrkD0_muon2 = MuonTrkD0->at(v_idx_muon_final[1]); NHits_muon2 = MuonTrkHits ->at(v_idx_muon_final[1]); Charge_muon2 = MuonCharge->at(v_idx_muon_final[1]); RelIso_muon2 = MuonRelIso->at(v_idx_muon_final[1]); TrkDZ_muon2 = MuonTrkDz->at(v_idx_muon_final[1]); TrkIso_muon2 = MuonTrkIso->at(v_idx_muon_final[1]); EcalIso_muon2 = MuonEcalIso->at(v_idx_muon_final[1]); HcalIso_muon2 = MuonHcalIso->at(v_idx_muon_final[1]); ChiSq_muon2 = MuonGlobalChi2->at(v_idx_muon_final[1]); QOverPError_muon2 = MuonQOverPError->at(v_idx_muon_final[1]); PhiError_muon2 = MuonPhiError->at(v_idx_muon_final[1]); EtaError_muon2 = MuonEtaError->at(v_idx_muon_final[1]); PtError_muon2 = MuonPtError->at(v_idx_muon_final[1]); // muon Pt/Eta/Phi Pt_muon2 = MuonPt->at(v_idx_muon_final[1]); Phi_muon2 = MuonPhi->at(v_idx_muon_final[1]); Eta_muon2 = MuonEta->at(v_idx_muon_final[1]); // Other Variables muon2.SetPtEtaPhiM(Pt_muon2,Eta_muon2,Phi_muon2,0); deltaPhi_muon1pfMET = (pfMET.DeltaPhi(muon1)); deltaPhi_muon1muon2 = (muon1.DeltaPhi(muon2)); deltaR_muon1muon2 = muon1.DeltaR(muon2); M_muon1muon2 = (muon1+muon2).M(); // Boson PT TLorentzVector UZ = -(pfMET + muon1 + muon2); TLorentzVector BZ = (muon1+muon2); U1_Z = (UZ.Pt()) * (cos(UZ.DeltaPhi(BZ))) ; U2_Z = (UZ.Pt()) * (sin(UZ.DeltaPhi(BZ))) ; Pt_Z = (muon1 + muon2).Pt(); Phi_Z = (muon1 + muon2).Phi(); } //======================== At least 1 PFJET ================================// if (PFJetCount>=1) { // Jet Quality PFJetNeutralMultiplicity_pfjet1= PFJetNeutralMultiplicity->at(v_idx_pfjet_final[0]); PFJetNeutralHadronEnergyFraction_pfjet1= PFJetNeutralHadronEnergyFraction->at(v_idx_pfjet_final[0]); PFJetNeutralEmEnergyFraction_pfjet1= PFJetNeutralEmEnergyFraction->at(v_idx_pfjet_final[0]); PFJetChargedMultiplicity_pfjet1= PFJetChargedMultiplicity->at(v_idx_pfjet_final[0]); PFJetChargedHadronEnergyFraction_pfjet1= PFJetChargedHadronEnergyFraction->at(v_idx_pfjet_final[0]); PFJetChargedEmEnergyFraction_pfjet1= PFJetChargedEmEnergyFraction->at(v_idx_pfjet_final[0]); // Pt/Eta/Phi Pt_pfjet1 = PFJetPt->at(v_idx_pfjet_final[0]); Phi_pfjet1 = PFJetPhi->at(v_idx_pfjet_final[0]); Eta_pfjet1 = PFJetEta->at(v_idx_pfjet_final[0]); // Other Variables pfjet1.SetPtEtaPhiM(Pt_pfjet1,Eta_pfjet1,Phi_pfjet1,0); deltaPhi_pfjet1pfMET = (pfMET.DeltaPhi(pfjet1)); MT_pfjet1pfMET = TMass(Pt_pfjet1,MET_pf,deltaPhi_pfjet1pfMET); BDisc_pfjet1 = PFJetTrackCountingHighEffBTag->at(v_idx_pfjet_final[0]); } //======================== At least 2 PFJET ================================// if (PFJetCount>=2) { // Pt/Eta/Phi Pt_pfjet2 = PFJetPt->at(v_idx_pfjet_final[1]); Phi_pfjet2 = PFJetPhi->at(v_idx_pfjet_final[1]); Eta_pfjet2 = PFJetEta->at(v_idx_pfjet_final[1]); // Jet Quality PFJetNeutralMultiplicity_pfjet2= PFJetNeutralMultiplicity->at(v_idx_pfjet_final[1]); PFJetNeutralHadronEnergyFraction_pfjet2= PFJetNeutralHadronEnergyFraction->at(v_idx_pfjet_final[1]); PFJetNeutralEmEnergyFraction_pfjet2= PFJetNeutralEmEnergyFraction->at(v_idx_pfjet_final[1]); PFJetChargedMultiplicity_pfjet2= PFJetChargedMultiplicity->at(v_idx_pfjet_final[1]); PFJetChargedHadronEnergyFraction_pfjet2= PFJetChargedHadronEnergyFraction->at(v_idx_pfjet_final[1]); PFJetChargedEmEnergyFraction_pfjet2= PFJetChargedEmEnergyFraction->at(v_idx_pfjet_final[1]); // Other Variables pfjet2.SetPtEtaPhiM(Pt_pfjet2,Eta_pfjet2,Phi_pfjet2,0); BDisc_pfjet2 = PFJetTrackCountingHighEffBTag->at(v_idx_pfjet_final[1]); deltaPhi_pfjet2pfMET = (pfMET.DeltaPhi(pfjet2)); MT_pfjet2pfMET = TMass(Pt_pfjet2,MET_pf,deltaPhi_pfjet2pfMET); deltaR_pfjet1pfjet2 = pfjet1.DeltaR(pfjet2); deltaPhi_pfjet1pfjet2 = (pfjet1.DeltaPhi(pfjet2)); M_pfjet1pfjet2 = (pfjet1 + pfjet2).M(); } //======================== 1 Muon 1 Jet ================================// if ((MuonCount>0) && (PFJetCount> 0)) { deltaPhi_muon1pfjet1 = (muon1.DeltaPhi(pfjet1)); deltaR_muon1pfjet1 = (muon1.DeltaR(pfjet1)); M_muon1pfjet1 = (pfjet1 + muon1).M(); MT_muon1pfjet1 = TMass(Pt_pfjet1,Pt_muon1,deltaPhi_muon1pfjet1); } //======================== 1 Muon 2 Jet ================================// if ((MuonCount>0) && (PFJetCount> 1)) { deltaPhi_muon1pfjet2 = (muon1.DeltaPhi(pfjet2)); deltaR_muon1pfjet2 = (muon1.DeltaR(pfjet2)); M_muon1pfjet2 = (pfjet2 + muon1).M(); MT_muon1pfjet2 = TMass(Pt_pfjet2,Pt_muon1,deltaPhi_muon1pfjet2); ST_pf_munu= Pt_muon1 + MET_pf + Pt_pfjet1 + Pt_pfjet2; } //======================== 2 Muon 1 Jet ================================// if ((MuonCount>1) && (PFJetCount> 0)) { deltaPhi_muon2pfjet1 = (muon2.DeltaPhi(pfjet1)); deltaR_muon2pfjet1 = (muon2.DeltaR(pfjet1)); M_muon2pfjet1 = (pfjet1+muon2).M(); MT_muon2pfjet1 = TMass(Pt_pfjet1,Pt_muon2,deltaPhi_muon2pfjet1); } //======================== 2 Muon 2 Jet ================================// if ((MuonCount>1) && (PFJetCount> 1)) { deltaPhi_muon2pfjet2 = (muon2.DeltaPhi(pfjet2)); deltaR_muon2pfjet2 = (muon2.DeltaR(pfjet2)); ST_pf_mumu= Pt_muon1 + Pt_muon2 + Pt_pfjet1 + Pt_pfjet2; M_muon2pfjet2 = (pfjet2 + muon2).M(); MT_muon2pfjet2 = TMass(Pt_pfjet2,Pt_muon2,deltaPhi_muon2pfjet2); M_muon1muon2pfjet1pfjet2 = (muon1+muon2+pfjet1+pfjet2).M(); } //======================== LQ Mass Concepts ================================// // DiMuon, minimizing differene between mu-jet masses if ((MuonCount>1) && (PFJetCount> 1)) { if (abs(M_muon1pfjet1 - M_muon2pfjet2) < abs(M_muon1pfjet2 - M_muon2pfjet1) ) { M_bestmupfjet1_mumu = M_muon1pfjet1; M_bestmupfjet2_mumu = M_muon2pfjet2; } if (abs(M_muon1pfjet1 - M_muon2pfjet2) > abs(M_muon1pfjet2 - M_muon2pfjet1) ) { M_bestmupfjet1_mumu = M_muon2pfjet1; M_bestmupfjet2_mumu = M_muon1pfjet2; } } // Beta - Half production - minimize difference of transverse masses if ((MuonCount>0) && (PFJetCount> 1)) { if (abs(MT_muon1pfjet1 - MT_pfjet2pfMET) < abs(MT_muon1pfjet2 - MT_pfjet1pfMET) ) { M_bestmupfjet_munu= M_muon1pfjet1; } if (abs(MT_muon1pfjet1 - MT_pfjet2pfMET) > abs(MT_muon1pfjet2 - MT_pfjet1pfMET) ) { M_bestmupfjet_munu= M_muon1pfjet2; } } tree->Fill(); // FILL FINAL TREE } tree->Write(); file1->Close(); }