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

Comparing UserCode/MitHzz4l/NonMCBackground/src/applyEMU.cc (file contents):
Revision 1.3 by khahn, Wed Jun 20 19:17:19 2012 UTC vs.
Revision 1.6 by dkralph, Fri Jul 6 15:01:29 2012 UTC

# Line 33 | Line 33 | using namespace std;
33   #include "Electron.h"
34   #include "Muon.h"
35   #include "Vertex.h"
36 + #include "PFJet.h"
37   #include "PFCandidate.h"
38   #include "PFCandidateCol.h"
39   #include "PileupInfoCol.h"
# Line 68 | Line 69 | using namespace std;
69  
70   #include "SampleWeight.h"
71   #include "EfficiencyWeightsInterface.h"
72 + #include "SelectionZ.h"
73  
74   #include "SimpleLepton.h"
75  
# Line 91 | Line 93 | map<unsigned,float>       evtrhoMap;
93   vector<string> cutstrs;
94   bool passes_HLT_MC;
95   vector<bool>   PFnoPUflag;;
96 + vector<int> muTrigObjs,eleTrigObjs,muTriggers,eleTriggers;
97 + std::bitset<TRIGGER_BIG_NUMBER> triggerBits;
98  
99   //
100   // prototypes
101   //----------------------------------------------------------------------------
102 < void initRunLumiRangeMap();
99 <
102 > void initRunLumiRangeMap(ControlFlags &ctrl);
103  
104   //
105   // MAIN
# Line 107 | Line 110 | int main(int argc, char** argv)
110  
111    string cmsswpath(CMSSW_BASE);
112    cmsswpath.append("/src");
110  std::bitset<1024> triggerBits;
113    map<string,unsigned> entrymap; // number of unskimmed entries in each file
114  
115    //
# Line 191 | Line 193 | int main(int argc, char** argv)
193    if(ctrl.mc) {
194      nt.makeWeightBranch(weights);
195      if(ctrl.fillGen ) nt.makeGenInfoBranch(geninfo);
196 <    initEfficiencyWeights();
196 >    // initEfficiencyWeights();
197 >    cout << "\n\nWARNING: not initializing eff weights\n\n" << endl;
198      initPUWeights();
199  
200      // Higgs only, pt reweighting
# Line 205 | Line 208 | int main(int argc, char** argv)
208      }
209  
210    } else {
211 <    initRunLumiRangeMap();
211 >    initRunLumiRangeMap(ctrl);
212    }
213  
214    //  initMuonIDMVA();
# Line 215 | Line 218 | int main(int argc, char** argv)
218    initElectronIsoMVA();
219    initTrigger();
220  
221 +  muTriggers.push_back(kHLT_IsoMu24_eta2p1);    muTrigObjs.push_back(kHLT_IsoMu24_eta2p1_MuObj);
222 +  eleTriggers.push_back(kHLT_Ele27_WP80);       eleTrigObjs.push_back(kHLT_Ele27_WP80_EleObj);
223 +
224    // hack
225    initEvtRhoMap(evtrhoMap);
226  
# Line 224 | Line 230 | int main(int argc, char** argv)
230    //--------------------------------------------------------------------------------------------------------------
231    string currentFile("");
232  
233 +  UInt_t fNMaxTriggers = TRIGGER_BIG_NUMBER;
234    mithep::EventHeader *info    = new mithep::EventHeader();
235    mithep::Array<mithep::PFMet>                *metArr        = new mithep::Array<mithep::PFMet>();
236    mithep::Array<mithep::Electron>             *electronArr   = new mithep::Array<mithep::Electron>();
237    mithep::Array<mithep::Muon>                 *muonArr       = new mithep::Array<mithep::Muon>();
238    mithep::Array<mithep::Vertex>               *vtxArr        = new mithep::Array<mithep::Vertex>();
239    mithep::Array<mithep::PFCandidate>          *pfArr         = new mithep::Array<mithep::PFCandidate>();
240 +  mithep::Array<mithep::PFJet>                *jetArr        = new mithep::Array<mithep::PFJet>();
241    mithep::Array<mithep::PileupInfo>           *puArr         = new mithep::Array<mithep::PileupInfo>();
242    mithep::Array<mithep::PileupEnergyDensity>  *puDArr        = new mithep::Array<mithep::PileupEnergyDensity>();
243    mithep::Array<mithep::Track>                *trkArr        = new mithep::Array<mithep::Track>();
# Line 238 | Line 246 | int main(int argc, char** argv)
246    mithep::TriggerMask                         *trigMask      = new mithep::TriggerMask();
247    mithep::TriggerTable                        *hltTable      = new mithep::TriggerTable();
248    vector<string>                              *hltTableStrings  = new vector<string>();
249 +  vector<string>                              *hltLabelStrings  = new vector<string>();
250 +  mithep::Array<mithep::TriggerObject>        *hltObjArr     = new mithep::Array<mithep::TriggerObject>();
251 +  mithep::Array<mithep::TriggerObjectRel>     *hltRelsArr    = new mithep::Array<mithep::TriggerObjectRel>();
252 +  std::vector<std::string>                    *hltTab        = new vector<string>();
253 +  std::vector<std::string>                    *hltLab        = new vector<string>();
254 +  mithep::TriggerObjectsTable                 *fTrigObjs     = new TriggerObjectsTable(hltTable,fNMaxTriggers);
255 +  mithep::Array<mithep::DecayParticle>        *fConversions  = new mithep::Array<mithep::DecayParticle>();
256  
242  TString fElectronName(Names::gkElectronBrn);
243  TString fMuonName(Names::gkMuonBrn);
244  TString fInfoName(Names::gkEvtHeaderBrn);
245  TString fPFMetName("PFMet");
246  TString fPrimVtxName(Names::gkPVBrn);
247  TString fPFCandidateName(Names::gkPFCandidatesBrn);
248  TString fPileupInfoName(Names::gkPileupInfoBrn);
249  TString fPileupEnergyDensityName(Names::gkPileupEnergyDensityBrn);
250  TString fTrackName(Names::gkTrackBrn);
251  TString fMCParticleName(Names::gkMCPartBrn);
252  TString fMCEvtInfoName(Names::gkMCEvtInfoBrn);
253  TString fTriggerMaskName(Names::gkHltBitBrn);
257    TString fTriggerTableName(Names::gkHltTableBrn);
258 <  
259 <  chain->SetBranchAddress(fInfoName,        &info);
260 <  chain->SetBranchAddress(fPFMetName,       &metArr);
261 <  chain->SetBranchAddress(fElectronName,    &electronArr);
262 <  chain->SetBranchAddress(fMuonName,        &muonArr);
263 <  chain->SetBranchAddress(fPrimVtxName,     &vtxArr);
264 <  chain->SetBranchAddress(fPFCandidateName, &pfArr);
258 >  chain->SetBranchAddress(Names::gkEvtHeaderBrn,                &info);
259 >  chain->SetBranchAddress("PFMet",                              &metArr);
260 >  chain->SetBranchAddress(Names::gkElectronBrn,                 &electronArr);
261 >  chain->SetBranchAddress(Names::gkMuonBrn,                     &muonArr);
262 >  chain->SetBranchAddress(Names::gkPVBrn,                       &vtxArr);
263 >  chain->SetBranchAddress(Names::gkPFCandidatesBrn,             &pfArr);
264 >  chain->SetBranchAddress(Names::gkPFJetBrn,                    &jetArr);
265    if( ctrl.mc ) {
266 <    chain->SetBranchAddress(fPileupInfoName,  &puArr);
267 <    chain->SetBranchAddress(fMCParticleName,  &mcArr);
268 <    chain->SetBranchAddress(fMCEvtInfoName,  &mcEvtInfo);
266 >    chain->SetBranchAddress(Names::gkPileupInfoBrn,             &puArr);
267 >    chain->SetBranchAddress(Names::gkMCPartBrn,                 &mcArr);
268 >    chain->SetBranchAddress(Names::gkMCEvtInfoBrn,              &mcEvtInfo);
269    }
270 <  chain->SetBranchAddress(fPileupEnergyDensityName, &puDArr);
271 <  chain->SetBranchAddress(fTrackName, &trkArr);
272 <  chain->SetBranchAddress(fTriggerMaskName, &trigMask);
273 <  cout << "hlttable: " << fTriggerTableName << endl;
274 <  hltchain->SetBranchAddress(fTriggerTableName, &hltTableStrings);
270 >  chain->SetBranchAddress(Names::gkPileupEnergyDensityBrn,      &puDArr);
271 >  chain->SetBranchAddress(Names::gkTrackBrn,                    &trkArr);
272 >  chain->SetBranchAddress(Names::gkHltBitBrn,                   &trigMask);
273 >  chain->SetBranchAddress(Names::gkHltObjBrn,                   &hltObjArr);
274 >  chain->SetBranchAddress("HLTObjectsRelation",                 &hltRelsArr);
275 >  chain->SetBranchAddress(Names::gkMvfConversionBrn,            &fConversions);
276 >  hltchain->SetBranchAddress(fTriggerTableName,                 &hltTableStrings);
277 >  hltchain->SetBranchAddress(Names::gkHltLabelBrn,              &hltLabelStrings);
278  
279    mithep::Vertex              vtx;          // best primary vertex in the event
280  
# Line 290 | Line 296 | int main(int argc, char** argv)
296      if(!(ientry%1000)) cerr << "entry: " << ientry << "\t" << float(ientry)/imax << endl;
297  
298      string fname = string(chain->GetFile()->GetEndpointUrl()->GetFile());
299 <    setEra( fname, ctrl );
300 <
299 >    if( ctrl.era == 0  )
300 >      setEra( fname, ctrl );
301  
302      // pfNoPU
303      PFnoPUflag.clear();
# Line 307 | Line 313 | int main(int argc, char** argv)
313        fillTriggerNames(hltTable, hltTableStrings );
314      }
315      fillTriggerBits( hltTable, trigMask, triggerBits );
316 +    setHLTObjectRelations( hltObjArr, hltRelsArr, hltTableStrings, hltLabelStrings, fTrigObjs );
317  
318      //
319      // data/MC
# Line 315 | Line 322 | int main(int argc, char** argv)
322        if( ctrl.fillGen )
323          fillGenInfo( mcArr, mcEvtInfo, geninfo, ESampleType::kHZZ, ctrl);
324      } else {
318      /*
319      // JSON
325        if(!(ctrl.noJSON) ) {
326 <      RunLumiRangeMap::RunLumiPairType rl(info->RunNum(), info->LumiSec());      
327 <      if( !(rlrm.HasRunLumi(rl)) )  {
323 <      if( ctrl.debug ) cout << "\tfails JSON" << endl;
324 <      continue;
326 >        RunLumiRangeMap::RunLumiPairType rl(info->RunNum(), info->LumiSec());      
327 >        if( !(rlrm.HasRunLumi(rl)) ) continue;
328        }
326      }
327      */
329        // if( !passHLTEMU(ctrl,triggerBits) ) {
330        //   continue;
331        // }
# Line 333 | Line 334 | int main(int argc, char** argv)
334      // lepton/kinematic selection ...
335      failingLeptons.clear();
336      passingLeptons.clear();
337 <    EventData ret4l =
337 >    EventData ret4l;
338          
339 <      apply_HZZ4L_EMU_selection(ctrl, info,
340 <                                vtxArr,
341 <                                pfArr,
342 <                                puDArr,
343 <                                electronArr,
344 <                                &electronReferencePreSelection,
345 <                                &electronReferenceIDMVASelectionV1,
346 <                                &electronReferenceIsoSelection,
347 <                                muonArr,
348 <                                &muonReferencePreSelection,
349 <                                &muonIDPFSelection,
350 <                                &muonReferenceIsoSelection);
351 <      
339 >    if(ctrl.fakeScheme.Contains("oneZ"))
340 >      ret4l = apply_HZZ4L_Z_selection(ctrl, info,
341 >                                      hltTable,
342 >                                      hltObjArr,
343 >                                      fTrigObjs,
344 >                                      vtxArr,
345 >                                      pfArr,
346 >                                      puDArr,
347 >                                      electronArr,
348 >                                      &electronReferencePreSelection,
349 >                                      &electronReferenceIDMVASelectionV1,
350 >                                      &electronReferenceIsoSelection,
351 >                                      muonArr,
352 >                                      &muonReferencePreSelection,
353 >                                      &muonIDPFSelection,
354 >                                      &muonReferenceIsoSelection);
355 >    else
356 >      ret4l = apply_HZZ4L_EMU_selection(ctrl, info,
357 >                                        hltTable,
358 >                                        hltObjArr,
359 >                                        fTrigObjs,
360 >                                        vtxArr,
361 >                                        pfArr,
362 >                                        puDArr,
363 >                                        fConversions,
364 >                                        electronArr,
365 >                                        &electronReferencePreSelection,
366 >                                        &electronReferenceIDMVASelectionV1,
367 >                                        &electronReferenceIsoSelection,
368 >                                        muonArr,
369 >                                        &muonReferencePreSelection,
370 >                                        &muonIDPFSelection,
371 >                                        &muonReferenceIsoSelection);
372        
373      if( ret4l.status.pass() ) {
374 <        
374 >      fillKinematics(ret4l,kinematics);
375        TLorentzVector pfmet; pfmet.SetPxPyPzE(metArr->At(0)->Mex(),metArr->At(0)->Mey(),0,0);
376 <      fillEventInfo(info,pfmet,evtinfo);
376 >      fillEventInfo( info, pfmet, evtinfo, ctrl.mc ? getNPU(puArr) : 0, vtxArr->GetEntries());
377        foTree.Fill();
357        
358      if( ctrl.mc)
359        setEffiencyWeights(ctrl.era, ret4l, weights);
360        
378        nt.Fill();
379      }
380 <      
380 >    
381    }
382    foTree.getFile()->cd();
383    foTree.getTree()->Write();
384    nt.WriteClose();
385   }
386   //----------------------------------------------------------------------------
387 < void initRunLumiRangeMap()
387 > void initRunLumiRangeMap(ControlFlags &ctrl)
388   //----------------------------------------------------------------------------
389   {
390    /*
# Line 381 | Line 398 | void initRunLumiRangeMap()
398    */
399  
400    // 2012 only for now ...
401 <  rlrm.AddJSONFile(std::string("./data/Cert_190456-194479_8TeV_PromptReco_Collisions12_JSON.txt"));  
401 >  rlrm.AddJSONFile(string(ctrl.jsonFile));
402  
403   };

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines