Selection/src/applySelection.cc

//
// System headers
//
#include <vector>                   // STL vector class
#include <iostream>                 // standard I/O
#include <iomanip>                  // functions to format standard I/O
#include <bitset>  
#include <map>  
using namespace std;

//
// root headers
//
#include <TFile.h>                  
#include <TTree.h>                  
#include <TChain.h>                 
#include <TBranch.h>                
#include <TClonesArray.h>           


//
// TMVA
//
#include "TMVA/Reader.h"
#include "TMVA/Tools.h"
#include "TMVA/Config.h"
#include "TMVA/MethodBDT.h"

//
// ntuple format headers
//
#include "EventHeader.h"
#include "Electron.h"
#include "Muon.h"
#include "Vertex.h"
#include "PFCandidate.h"
#include "PFCandidateCol.h"
#include "PileupInfoCol.h"
#include "PileupEnergyDensity.h"
#include "MCParticle.h"
#include "TriggerMask.h"
#include "TriggerTable.h"
#include "TriggerObject.h"
#include "TriggerObjectRel.h"
#include "Names.h"
#include "BaseMod.h"
#include "TriggerObjectsTable.h"

//
// our headers
//
#include "ParseArgs.h"
#include "MuonSelection.h"
#include "ElectronSelection.h"
#include "IsolationSelection.h"
#include "ReferenceSelection.h"

#include "TriggerUtils.h"
#include "PassHLT.h"
#include "Angles.h"
#include "KinematicsStruct.h"
#include "InfoStruct.h"
#include "GenInfoStruct.h"
#include "WeightStruct.h"
#include "AngleTuple.h"
#include "FOTuple.h"

#include "RunLumiRangeMap.h"
#include "SampleWeight.h"
#include "EfficiencyWeightsInterface.h"
#include "SelectionFuncs.h"

#include "SimpleLepton.h"

#ifndef CMSSW_BASE
#define CMSSW_BASE "../"
#endif

using namespace mithep;

//
// globals
//----------------------------------------------------------------------------
TH1D * hpu; 
RunLumiRangeMap rlrm;
vector<SimpleLepton> failingLeptons ; // for fake estimation
vector<SimpleLepton> passingLeptons;      // for fake estimation
vector<unsigned> cutvec;
vector<vector<unsigned> > zcutvec;
vector<vector<unsigned> > zzcutvec;
map<unsigned,float>       evtrhoMap;
vector<string> cutstrs;
bool passes_HLT_MC;
vector<bool>   PFnoPUflag;;

//
// prototypes
//----------------------------------------------------------------------------
void initPUWeights(); 
double getPUWeight(unsigned npu);
void initRunLumiRangeMap(); 
//----------------------------------------------------------------------------


//
// MAIN
//----------------------------------------------------------------------------
int main(int argc, char** argv) 
//----------------------------------------------------------------------------
{
  cutstrs.push_back(string("skim0"));              //0 
  cutstrs.push_back(string("skim1"));              //1 
  cutstrs.push_back(string("skim2"));              //1 
  cutstrs.push_back(string("trigger"));            //2 
  // -------------------------------------------------
  cutstrs.push_back(string("Z candidate"));        //3 
  cutstrs.push_back(string("good Z1"));            //4 
  // -------------------------------------------------
  cutstrs.push_back(string("4l"));                 //5  
  cutstrs.push_back(string("ZZ candidate"));       //6 
  cutstrs.push_back(string("good Z2"));            //7 
  cutstrs.push_back(string("ZZ 20/10"));           //8 
  cutstrs.push_back(string("resonance"));          //9 
  cutstrs.push_back(string("m4l>70"));             //10
  cutstrs.push_back(string("m4l>100, mZ2 > 12"));                  //11


  string cmsswpath(CMSSW_BASE);
  cmsswpath.append("/src");
  std::bitset<1024> triggerBits;
  vector<vector<string> > inputFiles;
  inputFiles.push_back(vector<string>());
  map<string,unsigned> entrymap; // number of unskimmed entries in each file
  for( int i=0; i<cutstrs.size(); i++ ) cutvec.push_back(0); 
  for( int i=0; i<2; i++ )  {
    zcutvec.push_back(vector<unsigned>()); 
    for( int j=0; j<cutstrs.size(); j++ ) zcutvec[i].push_back(0); 
  }
  for( int i=0; i<3; i++ )  {
    zzcutvec.push_back(vector<unsigned>()); 
    for( int j=0; j<cutstrs.size(); j++ ) zzcutvec[i].push_back(0); 
  }


  //
  // args
  //--------------------------------------------------------------------------------------------------------------
  ControlFlags ctrl;
  parse_args( argc, argv, ctrl );
  if( ctrl.inputfiles.empty() &&ctrl.inputfile.empty() ) 
    {
      cerr << "usage: applySelection.exe <flags> " << endl;
      cerr << "\tmandoatory flags : " << endl;
      cerr << "\t--inputfiles |  file containing a list of ntuples to run over" << endl;
      cerr << "\t--inputfile |  a file to run over" << endl;
      cerr << "\t--outputfile | file to store  selected evet" << endl;
      return 1;
    }
  ctrl.dump();


  //
  // File I/O
  //--------------------------------------------------------------------------------------------------------------
  TChain * chain = new TChain("Events");
  TChain * hltchain = new TChain("HLT");

  string fname;
  unsigned total_unskimmed=0;
  if( !ctrl.inputfiles.empty() ) { 
    ifstream f(ctrl.inputfiles.c_str());
    while (f >> fname) { 
      if( !(strncmp( fname.c_str(), "#", 1 ) ) ) continue; // skip commented lines
      cout << "adding inputfile : " << fname.c_str() << endl;
      entrymap[string(fname.c_str())] = unskimmedEntries(fname.c_str());
      cout << "unskimmed entries: " << entrymap[string(fname.c_str())] << endl;
      total_unskimmed += entrymap[string(fname.c_str())];
      chain->AddFile(fname.c_str());
      hltchain->AddFile(fname.c_str());
    }
  } else { 
    cout << "adding inputfile : " << ctrl.inputfile.c_str() << endl;
    unsigned unsk_ents = unskimmedEntries(ctrl.inputfile.c_str());
    entrymap[string(ctrl.inputfile.c_str())] = unsk_ents;
    cout << "unskimmed entries: " << unsk_ents << endl;
    total_unskimmed += unsk_ents;
    chain->AddFile(ctrl.inputfile.c_str());
    hltchain->AddFile(ctrl.inputfile.c_str());
  }
  // // write the total number of unskimmed events that went into making this output file to a text file
  // writeEntries(ctrl,total_unskimmed);

  const char * ofname;
  if( strcmp( ctrl.outputfile.c_str(), "") ) {
    ofname = ctrl.outputfile.c_str();
  } else {
    ofname = "tmp.root";
  }
  // table of cross section values   
  string xspath = (cmsswpath+string("/MitPhysics/data/xs.dat"));
  cout << "xspath: " << xspath.c_str() << endl;
  SimpleTable xstab(xspath.c_str());


  //
  // Setup
  //--------------------------------------------------------------------------------------------------------------
  Angles angles;
  KinematicsStruct kinematics;
  InfoStruct evtinfo;
  WeightStruct weights;
  GenInfoStruct geninfo;

  AngleTuple nt( (const char*)ofname, (const char*)"zznt");
  nt.makeAngleBranch(angles);
  nt.makeKinematicsBranch(kinematics);
  nt.makeInfoBranch(evtinfo);

  
  FOTuple foTree( nt.getFile(), (const char*)"FOtree");
  foTree.makeFailedLeptonBranch(failingLeptons);
  foTree.makePassedLeptonBranch(passingLeptons);

  TH1F * h_wf11_hpt;
  if(ctrl.mc) { 
    nt.makeWeightBranch(weights);
    if(ctrl.fillGen ) nt.makeGenInfoBranch(geninfo);
    if(ctrl.efftype != string("WTF?")) initEfficiencyWeights();
    initPUWeights();

    // Higgs only, pt reweighting
    if( ctrl.mH <= 140 ) { 
      char wptname[256];
      sprintf( wptname, "/data/blue/pharris/Flat/ntupler/root/weight_ptH_%i.root", ctrl.mH );
      TFile * f_hpt = new TFile(wptname);
      f_hpt->Print();
      sprintf(wptname, "weight_hqt_fehipro_fit_%i", ctrl.mH);
      h_wf11_hpt  = (TH1F*)(f_hpt->FindObjectAny(wptname));
    }

  } else { 
    initRunLumiRangeMap();
  }

  //  initMuonIDMVA();
  initElectronIDMVAV1();
  initTrigger();

  //
  // Setup tree I/O
  //--------------------------------------------------------------------------------------------------------------
  TFile *inputFile=0;
  TTree *eventTree=0;  
  string currentFile("");

  UInt_t fNMaxTriggers = 1024;
  mithep::EventHeader *info    = new mithep::EventHeader();
  mithep::Array<mithep::Electron>             *electronArr   = new mithep::Array<mithep::Electron>();
  mithep::Array<mithep::Muon>                 *muonArr       = new mithep::Array<mithep::Muon>();
  mithep::Array<mithep::Vertex>               *vtxArr        = new mithep::Array<mithep::Vertex>();
  mithep::Array<mithep::PFCandidate>          *pfArr         = new mithep::Array<mithep::PFCandidate>();
  mithep::Array<mithep::PileupInfo>           *puArr         = new mithep::Array<mithep::PileupInfo>();
  mithep::Array<mithep::PileupEnergyDensity>  *puDArr        = new mithep::Array<mithep::PileupEnergyDensity>();
  mithep::Array<mithep::Track>                *trkArr        = new mithep::Array<mithep::Track>();
  mithep::Array<mithep::MCParticle>           *mcArr         = new mithep::Array<mithep::MCParticle>();
  mithep::MCEventInfo                         *mcEvtInfo     = new mithep::MCEventInfo();
  mithep::TriggerMask                         *trigMask      = new mithep::TriggerMask();
  mithep::TriggerTable                        *hltTable      = new mithep::TriggerTable(fNMaxTriggers);
  vector<string>                              *hltTableStrings  = new vector<string>();
  vector<string>                              *hltLabelStrings  = new vector<string>();
  mithep::Array<mithep::TriggerObject>        *hltObjArr     = new mithep::Array<mithep::TriggerObject>();
  mithep::Array<mithep::TriggerObjectRel>     *hltRelsArr    = new mithep::Array<mithep::TriggerObjectRel>();
  std::vector<std::string>                    *hltTab        = new vector<string>();
  std::vector<std::string>                    *hltLab        = new vector<string>();
  TriggerObjectsTable                         *fTrigObjs     = new TriggerObjectsTable(hltTable,fNMaxTriggers);


  TString fElectronName(Names::gkElectronBrn);
  TString fMuonName(Names::gkMuonBrn);
  TString fInfoName(Names::gkEvtHeaderBrn);
  TString fPrimVtxName(Names::gkPVBrn);
  TString fPFCandidateName(Names::gkPFCandidatesBrn);
  TString fPileupInfoName(Names::gkPileupInfoBrn);
  TString fPileupEnergyDensityName(Names::gkPileupEnergyDensityBrn);
  TString fTrackName(Names::gkTrackBrn);
  TString fMCParticleName(Names::gkMCPartBrn);
  TString fMCEvtInfoName(Names::gkMCEvtInfoBrn);
  TString fTriggerMaskName(Names::gkHltBitBrn);
  TString fTriggerTableName(Names::gkHltTableBrn);
  TString fTriggerLabelName(Names::gkHltLabelBrn);
  TString fTriggerObjectName(Names::gkHltObjBrn);
  TString fTriggerObjectRelsName(Form("HLTObjectsRelation"));

//   TString fHLTLabName(Names::gkHltLabelBrn);
//   TString fHLTTabName(Names::gkHltTableBrn);
//   TString fHLTTabNamePub(Form("%sFwk",fHLTTabName.Data()));
//   TString fHLTLabNamePub(Form("%sFwk",fHLTLabName.Data()));
//   TString fObjsNamePub(Form("%sFwk",fTriggerObjectName.Data()));


  chain->SetBranchAddress(fInfoName,        &info);
  chain->SetBranchAddress(fElectronName,    &electronArr);
  chain->SetBranchAddress(fMuonName,        &muonArr);
  chain->SetBranchAddress(fPrimVtxName,     &vtxArr);
  chain->SetBranchAddress(fPFCandidateName, &pfArr);
  if( ctrl.mc ) { 
    chain->SetBranchAddress(fPileupInfoName,  &puArr);
    chain->SetBranchAddress(fMCParticleName,  &mcArr);
    chain->SetBranchAddress(fMCEvtInfoName,  &mcEvtInfo);
  }
  chain->SetBranchAddress(fPileupEnergyDensityName, &puDArr);
  chain->SetBranchAddress(fTrackName, &trkArr);
  chain->SetBranchAddress(fTriggerMaskName, &trigMask);
  chain->SetBranchAddress(fTriggerObjectName,  &hltObjArr);
  chain->SetBranchAddress(fTriggerObjectRelsName,  &hltRelsArr);
  //  chain->SetBranchAddress(fHLTTabNamePub,  &hltTab);
  //  chain->SetBranchAddress(fHLTLabNamePub,  &hltLab);

  cout << "hlttable: " << fTriggerTableName << endl;
  hltchain->SetBranchAddress(fTriggerTableName, &hltTableStrings);
  hltchain->SetBranchAddress(fTriggerLabelName, &hltLabelStrings);

  mithep::Vertex              vtx;          // best primary vertex in the event

  //  ginfo = NULL;
  // if( ctrl.mc ) { chain->SetBranchAddress("Gen",        &ginfo);}

  int count=0, pass=0;
  float passcorr=0., passcorr_errup=0., passcorr_errdown=0.;
  float denom[3]={0.,0.,0.};
  float numer[3]={0.,0.,0.};
  float numercorr[3]={0.,0.,0.};

  // only 1 HLT table / file ???
  hltchain->GetEntry(0);
  cerr << "here... " << endl;

  int imax = chain->GetEntries();
  cout << "nEntries: " << imax << endl;

  //
  // Loop !!!!!!!!! 
  //--------------------------------------------------------------------------------------------------------------
  for(UInt_t ientry=0; ientry<imax; ientry++) 
    {
      chain->GetEntry(ientry);
      if(!(ientry%1000)) cerr << "entry: " << ientry << endl;

      if( ctrl.debug ) {
        cout << "-----------------------------------------------------------------" << endl;
        cout << "-----------------------------------------------------------------" << endl;
        cout << "Run: " << info->RunNum() 
             << "\tEvt: " << info->EvtNum()
             << "\tLumi: " << info->LumiSec()
             << endl;
        cout << "-----------------------------------------------------------------" << endl;
      }


      string fname = string(chain->GetFile()->GetEndpointUrl()->GetFile());
      setEra( fname, ctrl );


      //
      // pfNoPU 
      //
      //mithep::Array<PFCandidate> pfNoPileUp;
      PFnoPUflag.clear();
      int pfnopu_size = makePFnoPUArray( pfArr, PFnoPUflag, vtxArr );
      assert(pfnopu_size == pfArr->GetEntries());

      //
      // data/MC
      //
      if(ctrl.mc) {
        //
        // gen info
        //
        if( ctrl.fillGen ) 
          fillGenInfo( mcArr, mcEvtInfo, geninfo, ESampleType::kHZZ, ctrl);

        //
        // xsec & PU weights
        //
        weights.w = getWeight(xstab,entrymap,chain)/ctrl.totalMC;
        cout << "xsec weight: " << weights.w << endl;
        int npu = -1;
        for(int i=0;i<puArr->GetEntries();i++) {
          if(puArr->At(i)->GetBunchCrossing() == 0)
            npu = puArr->At(i)->GetPU_NumInteractions();
        }
        assert(npu>=0);
        evtinfo.npu;
        weights.npuw = getPUWeight(evtinfo.npu);
        
        //
        // pt reweighting for Higgs < 140, F11
        //
        if( ctrl.fillGen ) { 
          if( (fname.find("f11-h115zz4l") != string::npos) || 
              (fname.find("f11-h120zz4l") != string::npos) || 
              (fname.find("f11-h130zz4l") != string::npos)  ) {
            weights.w *= h_wf11_hpt->GetBinContent(h_wf11_hpt->FindBin(geninfo.pt_zz));
          }
        }

        //
        // trigger 
        //
        if( string(chain->GetFile()->GetEndpointUrl()->GetFile()) != currentFile ) {
          currentFile = string(chain->GetFile()->GetEndpointUrl()->GetFile());
          hltchain->SetBranchAddress(fTriggerTableName, &hltTableStrings);
          hltchain->SetBranchAddress(fTriggerLabelName, &hltLabelStrings);
          hltchain->GetEntry(0);
          hltTable->Clear();
          fillTriggerNames(hltTable, hltTableStrings );
        }
        if( ctrl.debug ) cout << "file is : " << currentFile  << endl;
        fillTriggerBits( hltTable, trigMask, triggerBits );
        passes_HLT_MC = true; // passed to apply as extern global, just for sync 
        if( !passHLTMC(triggerBits, info->RunNum(), info->EvtNum(), k2012_MC ) ) {
          passes_HLT_MC = false;
        }

        setHLTObjectRelations( hltObjArr, hltRelsArr, hltTableStrings, hltLabelStrings, fTrigObjs );

      } else { 
        //
        // JSON
        //
        if(!(ctrl.noJSON) ) {
          RunLumiRangeMap::RunLumiPairType rl(info->RunNum(), info->LumiSec());      
          if( !(rlrm.HasRunLumi(rl)) )  {
            if( ctrl.debug ) cout << "fails JSON" << endl;
            continue;
          }
        }
        
        //
        // trigger 
        //
        if( string(chain->GetFile()->GetEndpointUrl()->GetFile()) != currentFile ) {
          currentFile = string(chain->GetFile()->GetEndpointUrl()->GetFile());
          hltchain->SetBranchAddress(fTriggerTableName, &hltTableStrings);
          hltchain->SetBranchAddress(fTriggerLabelName, &hltLabelStrings);
          hltchain->GetEntry(0);
          hltTable->Clear();
          fillTriggerNames(hltTable, hltTableStrings );
        }

        setHLTObjectRelations( hltObjArr, hltRelsArr, hltTableStrings, hltLabelStrings, fTrigObjs );
        printTriggerObjs( hltTable, fTrigObjs );

        if( ctrl.debug ) cout << "file is : " << currentFile  << endl;
        /*
        fillTriggerBits( hltTable, trigMask, triggerBits );
        if( !passHLT(triggerBits, info->RunNum(), info->EvtNum() ) ) { 
          if( ctrl.debug ) cout << "\tfails trigger ... " << endl;
          continue;
        }
        */
      }

      //
      // lepton/kinematic selection ...
      //
      failingLeptons.clear();
      passingLeptons.clear();
      EventData ret4l = 


        // reference
        apply_HZZ4L_reference_selection(ctrl, info, 
                                        vtxArr,
                                        pfArr,
                                        puDArr,
                                        electronArr, 
                                        &electronReferencePreSelection,
                                        &electronReferenceIDMVASelectionV1,
                                        &electronReferenceIsoSelection,
                                        muonArr, 
                                        &muonReferencePreSelection,
                                        &muonIDPFSelection,
                                        &muonReferenceIsoSelection);
      
      if( ctrl.debug ) cout << endl;


      int Z1type=0, Z2type=0;
      if( ret4l.status.selectionBits.to_ulong() >= PASS_ZCANDIDATE ) { 
        if( abs(ret4l.Z1leptons[0].type) == 11  ) Z1type = 11;
        if( abs(ret4l.Z1leptons[0].type) == 13  ) Z1type = 13;
      }  
      if( ret4l.status.selectionBits.to_ulong() >= PASS_ZZCANDIDATE ) { 
        if( abs(ret4l.Z2leptons[0].type) == 11  ) Z2type = 11;
        if( abs(ret4l.Z2leptons[0].type) == 13  ) Z2type = 13;
      }  
      
#ifdef SYNC
      cout  << "bits: " << ret4l.status.selectionBits  << "\t"
            << "Z1: " << Z1type << "\t"
            << "Z2: " << Z2type << endl;
      cout << endl;
#endif       
      
      if( ret4l.status.pass() ) { 
        fillAngles(ret4l,angles);
        fillKinematics(ret4l,kinematics);
        fillMassErrors(ret4l,muonArr,electronArr,kinematics);
        fillEventInfo(info,evtinfo);
        if( ctrl.mc) { 
          if( std::string(ctrl.efftype) != std::string("WTF?")) { 
            setEffiencyWeights(ret4l, weights); 
          } else {
            weights.won = weights.woff = 1.;
          }
          if(ctrl.debug) 
            cout << "w: " << weights.w << "\t"
                 << "won: " << weights.won << "\t"
                 << "woff: " << weights.woff << endl;
        }
        

        nt.Fill();
        
        cerr  << "PASS:: " 
              << "\trun: " << evtinfo.run
              << "\tevt: " << evtinfo.evt
              << "\tlumi: " << evtinfo.lumi
              << "\tcostheta1: " << angles.costheta1
              << "\tcostheta2: " << angles.costheta2
              << "\tcostheta*: " << angles.costhetastar
              << "\tbdt: " << angles.bdt
              << endl;
        pass++;
        //      if( pass > 3 ) break;

      } else if( ret4l.status.selectionBits.test(PASS_GOODZ1) && 
                 ret4l.status.selectionBits.to_ulong() < (1UL<<PASS_4L)) { // save for fakes ...
        if(ctrl.debug) {
          cout << "failingLeptons : " << failingLeptons.size() << endl;
          for( int f=0; f<failingLeptons.size(); f++ ) {
            SimpleLepton  l = failingLeptons[f];
            cout << "f: " << f << "\t"
                 << "type: " << l.type << "\t"
                 << "pT: " << l.vec.Pt()  << "\t"
                 << "eta: " << l.vec.Eta() 
                 << endl;
          }
        }
        foTree.Fill();
      } else { 
        cout << "failing with some other code : " << ret4l.status.selectionBits << endl;
      }
    }  

  
  foTree.getFile()->cd();
  foTree.getTree()->Write();
  nt.WriteClose();

  cout << endl;
  cout << endl;
  for( int i=0; i<cutvec.size(); i++ ) { 
    cout << "cut: " << i << "\t"
         << "pass: " << cutvec[i]; 

    if( i>PASS_TRIGGER&&i<=PASS_GOODZ1 ) 
      cout << "\t2e: " << zcutvec[0][i]
           << "\t2m: " << zcutvec[1][i];

    if( i>PASS_ZCANDIDATE ) 
      cout << "\t4e: " << zzcutvec[0][i]
           << "\t4m: " << zzcutvec[1][i]
           << "\t2e2m: " << zzcutvec[2][i];

    cout << "\t" << cutstrs[i] << endl;

    cout << endl;
  }

} 


//----------------------------------------------------------------------------
void initRunLumiRangeMap() 
//----------------------------------------------------------------------------
{
  /*
  rlrm.AddJSONFile(std::string("./data/Cert_136033-149442_7TeV_Apr21ReReco_Collisions10_JSON.txt"));
  //  rlrm.AddJSONFile(std::string("./data/Cert_160404-173244_7TeV_PromptReco_Collisions11_JSON_v2.txt"));
  rlrm.AddJSONFile(std::string("./data/Cert_160404-178078_7TeV_PromptReco_Collisions11_JSON.txt"));
  rlrm.AddJSONFile(std::string("./data/Cert_160404-163869_7TeV_May10ReReco_Collisions11_JSON_v3.txt"));  
  rlrm.AddJSONFile(std::string("./data/Cert_170249-172619_7TeV_ReReco5Aug_Collisions11_JSON.txt"));  
  // r11b
  rlrm.AddJSONFile(std::string("./data/Cert_160404-180252_7TeV_PromptReco_Collisions11_JSON.txt"));  
  */

  // 2012 only for now ...
  rlrm.AddJSONFile(std::string("./data/Cert_190456-194479_8TeV_PromptReco_Collisions12_JSON.txt"));  

};


//----------------------------------------------------------------------------
void initPUWeights() 
//----------------------------------------------------------------------------
{
  TFile * puf = new TFile("data/PileupReweighting.Summer11DYmm_To_Full2011.root");
  hpu = (TH1D*)(puf->Get("puWeights"));
}

//----------------------------------------------------------------------------
double getPUWeight(unsigned npu)
//----------------------------------------------------------------------------
{
  return hpu->GetBinContent(hpu->FindBin(npu)); 
}
Revision:	1.44
Committed:	Tue Jun 19 08:35:51 2012 UTC (12 years, 11 months ago) by dkralph
Content type:	text/plain
Branch:	MAIN
Changes since 1.43:	+25 -56 lines
Log Message:	Working on trigger matching