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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines