ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitHzz4l/Selection/src/Selection.cc
(Generate patch)

Comparing UserCode/MitHzz4l/Selection/src/Selection.cc (file contents):
Revision 1.12 by khahn, Sun Oct 23 10:53:01 2011 UTC vs.
Revision 1.14 by khahn, Tue Nov 1 19:15:53 2011 UTC

# Line 7 | Line 7
7   #include "HZZLikelihoodElectronSelection.h"
8   #include "HZZBDTElectronSelection.h"
9   #include "RunLumiRangeMap.h"
10 + #include "EfficiencyWeightsInterface.h"
11  
12   RunLumiRangeMap rlrm;
13  
14 < unsigned getGenChannel(mithep::TGenInfo * ginfo) {
15 <  int gchannel=-1;
16 <  if( abs(ginfo->id_1_a) == EGenType::kElectron && abs(ginfo->id_1_b) == EGenType::kElectron )  gchannel=0;
17 <  else if( abs(ginfo->id_1_a) == EGenType::kMuon && abs(ginfo->id_1_b) == EGenType::kMuon ) gchannel=1;
18 <  else if( (abs(ginfo->id_1_a) == EGenType::kElectron && abs(ginfo->id_1_b) == EGenType::kMuon) ||
19 <           (abs(ginfo->id_1_a) == EGenType::kMuon && abs(ginfo->id_1_b) == EGenType::kElectron) ) gchannel=2;
14 > // #include "TH2D.h"
15 > // extern TH2D * h_mu_eff_idiso_2011a;
16 > // extern TH2D * h_mu_eff_idiso_s11;
17 > // extern TH2D * h_mu_effdata_trigger_doublemu7_2011a;
18 > // extern TH2D * h_mu_effdata_trigger_doublemu13_8_leading_2011a;
19 > // extern TH2D * h_mu_effdata_trigger_doublemu13_8_trailing_2011a;
20 >
21 > // unsigned getGenChannel(mithep::TGenInfo * ginfo) {
22 > //   int gchannel=-1;
23 > //   if( abs(ginfo->id_1_a) == EGenType::kElectron && abs(ginfo->id_1_b) == EGenType::kElectron )  gchannel=0;
24 > //   else if( abs(ginfo->id_1_a) == EGenType::kMuon && abs(ginfo->id_1_b) == EGenType::kMuon ) gchannel=1;
25 > //   else if( (abs(ginfo->id_1_a) == EGenType::kElectron && abs(ginfo->id_1_b) == EGenType::kMuon) ||
26 > //         (abs(ginfo->id_1_a) == EGenType::kMuon && abs(ginfo->id_1_b) == EGenType::kElectron) ) gchannel=2;
27    
28 <  return gchannel;
29 < };
28 > //   return gchannel;
29 > // };
30  
23 –
31   void initRunLumiRangeMap() {
32    rlrm.AddJSONFile(std::string("./data/Cert_136033-149442_7TeV_Apr21ReReco_Collisions10_JSON.txt"));
33    //  rlrm.AddJSONFile(std::string("./data/Cert_160404-173244_7TeV_PromptReco_Collisions11_JSON_v2.txt"));
# Line 29 | Line 36 | void initRunLumiRangeMap() {
36    rlrm.AddJSONFile(std::string("./data/Cert_170249-172619_7TeV_ReReco5Aug_Collisions11_JSON.txt"));  
37   };
38  
39 < unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
40 <                               mithep::TEventInfo *info,     // input event inof
41 <                               TClonesArray *electronArr,    // input electrons
42 <                               TClonesArray *muonArr,        // input muons
43 <                               double eventweight,           // weight
44 <                               TTree * passtuple ) {
39 > void initRunLumiRangeMap(RunLumiRangeMap &rlrm) {
40 >  cout << "adding JSONS ... "  << endl;
41 >  rlrm.AddJSONFile(std::string("./data/Cert_136033-149442_7TeV_Apr21ReReco_Collisions10_JSON.txt"));
42 >  //  rlrm.AddJSONFile(std::string("./data/Cert_160404-173244_7TeV_PromptReco_Collisions11_JSON_v2.txt"));
43 >  rlrm.AddJSONFile(std::string("./data/Cert_160404-178078_7TeV_PromptReco_Collisions11_JSON.txt"));
44 >  rlrm.AddJSONFile(std::string("./data/Cert_160404-163869_7TeV_May10ReReco_Collisions11_JSON_v3.txt"));  
45 >  rlrm.AddJSONFile(std::string("./data/Cert_170249-172619_7TeV_ReReco5Aug_Collisions11_JSON.txt"));  
46 > };
47  
48 <  fails_HZZ4L_selection( ctrl, NULL, info, electronArr, muonArr, eventweight, passtuple, NULL );
48 > // unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
49 > //                             mithep::TEventInfo *info,     // input event inof
50 > //                             TClonesArray *electronArr,    // input electrons
51 > //                             TClonesArray *muonArr,        // input muons
52 > //                             double eventweight,           // weight
53 > //                             TTree * passtuple ) {
54  
55 < };
55 > //   fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, passtuple, NULL );
56  
57 + // };
58  
59  
45 – unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
46 –                               mithep::TEventInfo *info,     // input event inof
47 –                               TClonesArray *electronArr,    // input electrons
48 –                               TClonesArray *muonArr,        // input muons
49 –                               double eventweight,           // weight
50 –                               LabVectors  *l ) {
60  
61 <  fails_HZZ4L_selection( ctrl, NULL, info, electronArr, muonArr, eventweight, NULL, l );
61 > // unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
62 > //                             mithep::TEventInfo *info,     // input event inof
63 > //                             TClonesArray *electronArr,    // input electrons
64 > //                             TClonesArray *muonArr,        // input muons
65 > //                             double eventweight,           // weight
66 > //                             LabVectors  *l ) {
67  
68 < };
68 > //   fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, NULL, l );
69 >
70 > // };
71  
72  
73   unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
# Line 62 | Line 78 | unsigned fails_HZZ4L_selection(ControlFl
78                                 double eventweight,           // weight
79                                 TTree * passtuple ) {
80  
81 <  fails_HZZ4L_selection( ctrl, ginfo, info, electronArr, muonArr, eventweight, passtuple, NULL );
81 >  fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, passtuple, NULL, NULL );
82  
83   };
84  
85 + unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
86 +                               mithep::TEventInfo *info,     // input event info
87 +                               TClonesArray *electronArr,    // input electrons
88 +                               TClonesArray *muonArr,        // input muons
89 +                               double eventweight,           // weight
90 +                               TTree * passtuple,
91 +                               LabVectors * l ) {
92 +  fails_HZZ4L_selection( ctrl, info, electronArr, muonArr, eventweight, passtuple, l, NULL );
93 + }
94 +
95  
96   unsigned fails_HZZ4L_selection(ControlFlags &ctrl,           // input control
71 –                               mithep::TGenInfo *ginfo,     // input gen info
97                                 mithep::TEventInfo *info,     // input event info
98                                 TClonesArray *electronArr,    // input electrons
99                                 TClonesArray *muonArr,        // input muons
100                                 double eventweight,           // weight
101                                 TTree * passtuple,
102 <                               LabVectors * l) {       // output ntuple
102 >                               LabVectors * l=NULL,
103 >                               TClonesArray *jetArr=NULL ) {       // output ntuple
104  
105    unsigned evtfail = 0x0;
106    unsigned gchannel=0xdeaddead;
107  
108 <  if( ctrl.mc && ginfo != NULL ) {
109 <    gchannel = getGenChannel(ginfo);
110 <  }
108 > //   if( ctrl.mc && ginfo != NULL ) {
109 > //     gchannel = getGenChannel(ginfo);
110 > //   }
111  
112  
113    if( ctrl.debug ) {
# Line 110 | Line 136 | unsigned fails_HZZ4L_selection(ControlFl
136    //********************************************************
137    if( !ctrl.mc ) {
138      //  if( !(passHLT(info->triggerBits, info->runNum, channel) )  ) {
139 <    if( !(passHLT(info->triggerBits, info->runNum, 999) )  ) {
140 <      evtfail |= (1<<EVTFAIL_TRIGGER);
141 <      return evtfail;
142 <    }  
139 > //     if( !(passHLT(info->triggerBits, info->runNum, 999) )  ) {
140 > //       evtfail |= (1<<EVTFAIL_TRIGGER);
141 > //       return evtfail;
142 > //     }        
143    } else {
144      if( !(passHLTMC(info->triggerBits)) ) {
145        evtfail |= (1<<EVTFAIL_TRIGGER);
# Line 152 | Line 178 | unsigned fails_HZZ4L_selection(ControlFl
178      }
179      if ( !muonfail ) {
180        SimpleLepton tmplep;
181 <      tmplep.vec.SetPtEtaPhiM(mu->pt,
181 >
182 >      float pt = mu->pt;
183 >      if( ctrl.do_escale_up   ) pt*=(1.01);
184 >      if( ctrl.do_escale_down ) pt*=(0.99);
185 >
186 >      tmplep.vec.SetPtEtaPhiM(pt,
187                                mu->eta,
188                                mu->phi,
189                                105.658369e-3);
190 +
191        tmplep.type    = 13;
192        tmplep.index   = i;
193        tmplep.charge  = mu->q;
# Line 178 | Line 210 | unsigned fails_HZZ4L_selection(ControlFl
210    for(Int_t i=0; i<electronArr->GetEntries(); i++) {
211      const mithep::TElectron *ele = (mithep::TElectron*)((*electronArr)[i]);
212  
213 +    if( !(isEleFO(ctrl,ele) ) ) continue;
214 +    if( ele->pt < 7 ) continue; //move this to ID
215 +
216      Bool_t isMuonOverlap = kFALSE;
217      for (int k=0; k<lepvec.size(); ++k) {
218        TVector3 tmplep;
# Line 230 | Line 265 | unsigned fails_HZZ4L_selection(ControlFl
265        }
266        FAIL = failsBDT;
267      }
233 –    unsigned  failsSi=0;
234 –    if(ctrl.eleSele=="si") {
235 –      failsSi = failsSiMVAElectronSelection(ctrl, ele, 0.95, ctrl.kinematics);
236 –      FAIL = failsSi;
237 –    }
238 –
239 –
268  
269  
270      if( ctrl.debug ){
# Line 253 | Line 281 | unsigned fails_HZZ4L_selection(ControlFl
281      }
282      if ( !FAIL && !isMuonOverlap ) {
283        SimpleLepton tmplep;
284 <      tmplep.vec.SetPtEtaPhiM( ele->pt,
284 >
285 >      float pt = ele->pt;
286 >      if( ctrl.do_escale_up   ) pt*=(1.02);
287 >      if( ctrl.do_escale_down ) pt*=(0.98);
288 >
289 >      tmplep.vec.SetPtEtaPhiM( pt,
290                                 ele->eta,
291                                 ele->phi,
292                                 0.51099892e-3 );
# Line 276 | Line 309 | unsigned fails_HZZ4L_selection(ControlFl
309    
310    sort( lepvec.begin(), lepvec.end(), SimpleLepton::lep_pt_sort );
311  
312 +  for( int i=0; i<lepvec.size(); i++ ) {
313 +    //
314 +    //  check for a matched btagged jet
315 +    //
316 +    lepvec[i].tche = -1;
317 +    lepvec[i].tchp = -1;
318 +    lepvec[i].csv = -1;
319 +    lepvec[i].csvMva = -1;
320 +
321 +    if( jetArr != NULL ) {
322 +      for(int k=0; k<jetArr->GetEntries(); k++) {
323 +        const mithep::TJet *jet = (mithep::TJet*)((*jetArr)[k]);      
324 +        TVector3 jvec;
325 +        jvec.SetPtEtaPhi(jet->pt, jet->eta, jet->phi);
326 +        if( jvec.DrEtaPhi( lepvec[i].vec.Vect()) < 0.2 ) {
327 +          lepvec[i].tche = jet->tche;
328 +          lepvec[i].tchp = jet->tchp;
329 +          lepvec[i].csv = jet->csv;
330 +          lepvec[i].csvMva = jet->csvMva;
331 +        }
332 +      }
333 +    }
334 +  }
335 +
336    int nmu=0, nele=0;
337    for( int i=0; i<lepvec.size(); i++ ) {
338      if( abs(lepvec[i].type) == 11 ) nele++;
# Line 532 | Line 589 | unsigned fails_HZZ4L_selection(ControlFl
589  
590              if( abs(lepvec[i].type) == 13 ) {
591  
592 +              /*
593                float reliso = lepvec[i].isoPF03/lepvec[i].vec.Pt();
594                if( lepvec[i].isEB && lepvec[i].vec.Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {  //0.13
595                  failiso = true;
# Line 549 | Line 607 | unsigned fails_HZZ4L_selection(ControlFl
607                  failiso = true;
608                  break;
609                }
610 +              */
611              }
612            }  
613          } else if ( ctrl.isoScheme == "pairwise" ) {
# Line 692 | Line 751 | unsigned fails_HZZ4L_selection(ControlFl
751              (lepvec[Z1LeptonMinusIndex].type == 13 && lepvec[Z2LeptonMinusIndex].type == 11)) channel=2;
752          
753  
754 +        double w_offline=-1, werr_offline=0;
755 +        double w_online=-1, werr_online=0;
756  
757 +        if( ctrl.mc ) {
758 +
759 +          vector< pair <double,double> > wlegs; // pair here is eff & err
760 +          vector< pair <float,float> > mvec;  // pair here is eta & pt
761 +          // now deal with medium vs loose
762 +          //      vector< pair <float,float> > evec;  // pair here is eta & pt
763 +          vector< pair< bool, pair <float,float> > > evec;  // pair here is eta & pt
764 +
765 +          for( int k=0; k<lepvec.size(); k++ ) {
766 +            if( !(lepvec[k].is4l) ) continue;
767 +            if( abs(lepvec[k].type) == 13 ) {
768 +              mvec.push_back( std::pair<float,float> (fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt()) );
769 +              wlegs.push_back( muonPerLegOfflineEfficiencyWeight( fabs(lepvec[k].vec.Eta()),
770 +                                                                  lepvec[k].vec.Pt() ) );
771 +            } else {
772 +
773 +              // now deal with medium vs loose
774 +              //              evec.push_back( std::pair<float,float> (fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt()) );
775 +
776 +              std::pair<float,float> tmppair(fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt());
777 +              evec.push_back( std::pair<bool, std::pair<float,float> > (lepvec[k].isTight, tmppair) );
778 +
779 +              wlegs.push_back( elePerLegOfflineEfficiencyWeight(  fabs(lepvec[k].vec.Eta()),
780 +                                                                 lepvec[k].vec.Pt() ) );
781 +            }
782 +          }
783 +
784 +          pair<double,double> offpair = getOfflineEfficiencyWeight( wlegs );
785 +          w_offline    = offpair.first;
786 +          werr_offline = offpair.second;
787 +
788 +          pair<double,double> onpair  = getOnlineEfficiencyWeight( mvec, evec );
789 +          w_online    = onpair.first;
790 +          werr_online = onpair.second;
791 +
792 +        } // if mc
793 +
794 +
795 +        if( l != NULL ) {
796 +          l->vec4l  = ZZSystem;
797 +          l->vecz1  = Z1Candidate;
798 +          l->vecz2  = Z2Candidate;
799 +          l->vecl1p = lepvec[Z1LeptonPlusIndex].vec;
800 +          l->vecl1m = lepvec[Z1LeptonMinusIndex].vec;
801 +          l->vecl2p = lepvec[Z2LeptonPlusIndex].vec;
802 +          l->vecl2m = lepvec[Z2LeptonMinusIndex].vec;
803 +        }
804          if( passtuple != NULL ) {
805            unsigned run   = info->runNum;
806            unsigned evt   = info->evtNum;
# Line 705 | Line 813 | unsigned fails_HZZ4L_selection(ControlFl
813            float pt4l     = ZZSystem.Pt() ;
814            unsigned tZ1   = abs(lepvec[Z1LeptonMinusIndex].type);
815            unsigned tZ2   = abs(lepvec[Z2LeptonMinusIndex].type);
816 +          float l3tche   = lepvec[Z2LeptonMinusIndex].tche;
817 +          float l4tche   = lepvec[Z2LeptonPlusIndex].tche;
818 +          float l3tchp   = lepvec[Z2LeptonMinusIndex].tchp;
819 +          float l4tchp   = lepvec[Z2LeptonPlusIndex].tchp;
820 +          float l3csv    = lepvec[Z2LeptonMinusIndex].csv;
821 +          float l4csv    = lepvec[Z2LeptonPlusIndex].csv;
822 +          float l3csvMva = lepvec[Z2LeptonMinusIndex].csvMva;
823 +          float l4csvMva = lepvec[Z2LeptonPlusIndex].csvMva;
824 +
825 +
826            passtuple->SetBranchAddress("channel",  &channel);
827            passtuple->SetBranchAddress("run",  &run);
828            passtuple->SetBranchAddress("evt",  &evt);
# Line 716 | Line 834 | unsigned fails_HZZ4L_selection(ControlFl
834            passtuple->SetBranchAddress("m4l",  &m4l);
835            passtuple->SetBranchAddress("pt4l", &pt4l);
836            passtuple->SetBranchAddress("w",    &w);
837 +          if( ctrl.mc ) {
838 +            passtuple->SetBranchAddress("woff", &w_offline );
839 +            passtuple->SetBranchAddress("werroff", &werr_offline );
840 +            passtuple->SetBranchAddress("won", &w_online );
841 +            passtuple->SetBranchAddress("werron", &werr_online );
842 +          }
843 +          if( ctrl.btag ) {
844 +          passtuple->SetBranchAddress("l3tche",    &l3tche);
845 +          passtuple->SetBranchAddress("l4tche",    &l4tche);
846 +          passtuple->SetBranchAddress("l3tchp",    &l3tchp);
847 +          passtuple->SetBranchAddress("l4tchp",    &l4tchp);
848 +          passtuple->SetBranchAddress("l3csv",     &l3csv);
849 +          passtuple->SetBranchAddress("l4csv",     &l4csv);
850 +          passtuple->SetBranchAddress("l3csvMva",  &l3csvMva);
851 +          passtuple->SetBranchAddress("l4csvMva",  &l4csvMva);
852 +          }
853 +
854            if( ctrl.mc )           passtuple->SetBranchAddress("gchannel",  &gchannel);
855            passtuple->Fill( );
856 +
857          }
858  
859          if( ctrl.debug ) cout  << "run: " << info->runNum  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines