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 "Names.h"
#include "BaseMod.h"

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

//#include "Selection.h"
//#include "ReferenceSelection.h"
#include "ReferenceSelection2.h"

#include "TriggerUtils.h"
#include "PassHLT.h"
#include "Angles.h"
#include "KinematicsStruct.h"
#include "InfoStruct.h"
//#include "GenInfoStruct.h"
#include "WeightStruct.h"
//#include "GlobalDataAndFuncs.h"
#include "RunLumiRangeMap.h"

#include "AngleTuple.h"
#include "FOTuple.h"

#include "SampleWeight.h"
#include "EfficiencyWeightsInterface.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 setEffiencyWeights(EventData&, WeightStruct& ); 
void initRunLumiRangeMap(); 
void initEvtRhoMap(map<unsigned,float> &); 
unsigned makePFnoPUArray(mithep::Array<PFCandidate> * fPFCandidates,
                         vector<bool> &pfNoPileUpFlag,
                         const mithep::VertexCol     * vtxArr );
//----------------------------------------------------------------------------


//
// 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;
  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;
      chain->AddFile(fname.c_str());
      hltchain->AddFile(fname.c_str());
    }
  } else { 
    cout << "adding inputfile : " << ctrl.inputfile.c_str() << endl;
    unsigned tmpent = unskimmedEntries(ctrl.inputfile.c_str());
    cout << "tmpent: " << tmpent << endl; 
    entrymap[string(ctrl.inputfile.c_str())] = unskimmedEntries(ctrl.inputfile.c_str());
    cout << "unskimmed entries: " << entrymap[string(ctrl.inputfile.c_str())] << endl;
    chain->AddFile(ctrl.inputfile.c_str());
    hltchain->AddFile(ctrl.inputfile.c_str());
  }

  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.makeZLeptonBranch(passingLeptons);

  TH1F * h_w_hpt;
  if(ctrl.mc) { 
    nt.makeWeightBranch(weights);
    //    nt.makeGenInfoBranch(geninfo);
    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_w_hpt  = (TH1F*)(f_hpt->FindObjectAny(wptname));
      h_w_hpt->Print();
    }
    */
  } else { 
    initRunLumiRangeMap();
  }

  //  initMuonIDMVA();
  initMuonIsoMVA();
  initElectronIDMVA();
  initElectronIsoMVA();
  initTrigger();

  // hack 
  initEvtRhoMap(evtrhoMap);

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

  mithep::EventHeader *info    = new mithep::EventHeader();
  //  mithep::TGenInfo    *ginfo  = new mithep::TGenInfo();
  mithep::Array<mithep::Electron>             *electronArr   = new mithep::Array<mithep::Electron>();
  mithep::Array<mithep::Muon>                 *muonArr       = new mithep::Array<mithep::Muon>();
  const mithep::VertexCol              *vtxArr        = 0;//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::TriggerMask                         *trigMask      = new mithep::TriggerMask();
  mithep::TriggerTable                        *hltTable      = new mithep::TriggerTable();
  vector<string>                              *hltTableStrings  = new vector<string>();

  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 fTriggerMaskName(Names::gkHltBitBrn);
  TString fTriggerTableName(Names::gkHltTableBrn);
  
  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(fPileupEnergyDensityName, &puDArr);
  chain->SetBranchAddress(fTrackName, &trkArr);
  chain->SetBranchAddress(fTriggerMaskName, &trigMask);
  cout << "hlttable: " << fTriggerTableName << endl;
  hltchain->SetBranchAddress(fTriggerTableName, &hltTableStrings);

  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);

      /*
      bool found_tau=false;
      if( ctrl.mc) {  // && ctrl.debug 
        cout << "nparticles: " << mcArr->GetEntries() << endl;
        cout << "-----------------------------------" << endl;
        for( int i=0; i<mcArr->GetEntries(); i++ ) {
          const mithep::MCParticle *mc = mcArr->At(i);
          cout << "i: " << i << "\t" 
               << "id: " << mc->AbsPdgId() 
               << endl;
          if( mc->Is(MCParticle::kTau) ) { 
            found_tau=true;
          }
        }
      }
      cout << "-----------------------------------" << endl;
      cout << "found tau: " << found_tau << endl;
      */

      // events that fail bc ele overlaps w/ reco mu
      /*
      if( info->EvtNum() != 67315 && 
          info->EvtNum() != 288693 ) continue;
      */

      // events where they apparently don't veto electrons ...
      /*
      if( info->EvtNum() != 141713 && 
          info->EvtNum() != 178019 &&
          info->EvtNum() != 60823 && 
          info->EvtNum() != 192795 ) continue;
      */

      if(!(ientry%1000)) cerr << "entry: " << ientry << endl;
      //if (!(setPV( ctrl, vtxArr, vtx)) ) continue;

      float rho = evtrhoMap[info->EvtNum()]; 

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

      //
      // data/MC
      //
      if(ctrl.mc) {
        //
        // xsec & PU weights
        //
        weights.w = 1;//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);
        //      cout << "weight: " << weights.w << endl;
        //
        // trigger 
        //
        if( string(chain->GetFile()->GetEndpointUrl()->GetFile()) != currentFile ) {
          currentFile = string(chain->GetFile()->GetEndpointUrl()->GetFile());
          hltchain->SetBranchAddress(fTriggerTableName, &hltTableStrings);
          hltchain->GetEntry(0);
          hltTable->Clear();
          fillTriggerBits(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() ) ) {
          passes_HLT_MC = false;
        }
      } else { 
        //
        // JSON
        //
        /*
        RunLumiRangeMap::RunLumiPairType rl(info->RunNum(), info->LumiSec());      
        if( !(rlrm.HasRunLumi(rl)) )  {
          if( ctrl.debug ) cout << "\tfails JSON" << endl;
          continue;
        }
        */
        //
        // trigger 
        //
        if( string(chain->GetFile()->GetEndpointUrl()->GetFile()) != currentFile ) {
          currentFile = string(chain->GetFile()->GetEndpointUrl()->GetFile());
          hltchain->SetBranchAddress(fTriggerTableName, &hltTableStrings);
          hltchain->GetEntry(0);
          hltTable->Clear();
          fillTriggerBits(hltTable, hltTableStrings );
        }
        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_reference2_selection(ctrl, info, 
                                         vtxArr,
                                         pfArr,
#ifdef HACKED_RHOS
                                         rho,
#else
                                         puDArr,
#endif
                                         electronArr, 
                                         &electronReferencePreSelection,
                                         &electronReferenceIDMVASelection,
                                         &electronReferenceIsoSelection,
                                         muonArr, 
                                         &muonReferencePreSelection,
                                         &muonIDPFSelection,
                                         &muonReferenceIsoSelection);

      /*
        // evolved
        apply_HZZ4L_reference2_selection(ctrl, info, 
                                         vtx,
                                         pfArr,
                                         //rho,
                                         puDArr,
                                         electronArr, 
                                         &electronReferencePreSelection,
                                         //&electronPreSelection,
                                         &electronReferenceIDMVASelection,
                                         &electronIsoMVASelection,
                                         muonArr, 
                                         &muonReferencePreSelection,
                                         //&muonPreSelection,
                                         &muonIDPFSelection,
                                         &muonIsoMVASelection);
      */

      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);
        fillEventInfo(info,evtinfo);
        if( ctrl.mc) { 
        // fillGenInfo(ginfo,geninfo);
          setEffiencyWeights(ret4l, weights); 
           if(ctrl.debug) 
             cout << "w: " << weights.w << "\t"
                  << "won: " << weights.won << "\t"
                  << "woff: " << weights.woff << endl;
        }
        
        /*
        // only for Higgs < 140
        geninfo.weight *= h_w_hpt->GetBinContent(h_w_hpt->FindBin(geninfo.pt_zz));
        angles.bdt = reader->EvaluateMVA("BDTG");
        */
        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) ) { // 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();
      }
    }  

  
  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 setEffiencyWeights(EventData & evtdat, WeightStruct & weights ) 
//----------------------------------------------------------------------------
{
  vector<SimpleLepton> lepvec = evtdat.Z1leptons;
  lepvec.insert(lepvec.end(), evtdat.Z2leptons.begin(), evtdat.Z2leptons.end());
  double w_offline=-1, werr_offline=0;
  double w_online=-1, werr_online=0;
  
  vector< pair <double,double> > wlegs; // pair here is eff & err
  vector< pair <float,float> > mvec;  // pair here is eta & pt

  //      vector< pair <float,float> > evec;  // pair here is eta & pt
  // now deal with medium vs loose
  vector< pair< bool, pair <float,float> > > evec;  // pair here is eta & pt
  
  for( int k=0; k<lepvec.size(); k++ ) {
    if( abs(lepvec[k].type) == 13 ) {
      mvec.push_back( std::pair<float,float> (fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt()) );
      wlegs.push_back( muonPerLegOfflineEfficiencyWeight( fabs(lepvec[k].vec.Eta()), 
                                                          lepvec[k].vec.Pt() ) );
    } else { 
      
      // now deal with medium vs loose
      //              evec.push_back( std::pair<float,float> (fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt()) );
      
      std::pair<float,float> tmppair(fabs(lepvec[k].vec.Eta()), lepvec[k].vec.Pt()); 
      evec.push_back( std::pair<bool, std::pair<float,float> > (lepvec[k].isTight, tmppair) );
      
      //              wlegs.push_back( elePerLegOfflineEfficiencyWeight(  fabs(lepvec[k].vec.Eta()), 
      //                                                                 lepvec[k].vec.Pt() ) );
      
      wlegs.push_back( elePerLegOfflineEfficiencyWeight(  fabs(lepvec[k].vec.Eta()), 
                                                          lepvec[k].vec.Pt(),
                                                          lepvec[k].isTight ) );
      
    }
  }
  
  pair<double,double> offpair = getOfflineEfficiencyWeight( wlegs ); 
  weights.woff    = offpair.first;
  weights.werroff = offpair.second;
  
  pair<double,double> onpair  = getOnlineEfficiencyWeight( mvec, evec );
  weights.won    = onpair.first;
  weights.werron = onpair.second;
} 


//----------------------------------------------------------------------------
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"));  
  */
};


//----------------------------------------------------------------------------
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)); 
}

//----------------------------------------------------------------------------
void initEvtRhoMap( map<unsigned, float> & evtrhoMap )
//----------------------------------------------------------------------------
{
  unsigned evt;
  float rho;

  cout << "initialzing EvtRhoMap ";
  //FILE * f = fopen("evtrho.dat", "r");
  //  FILE * f = fopen("allrho.cali.uniq.dat", "r");
  FILE * f = fopen("/data/blue/khahn/CMSSW_4_4_2/src/MitHzz4l/allrhoAA.cali.uniq.dat", "r");
  int lcount=0;
  while( fscanf( f, "%u:%f", &evt, &rho ) ) {
    if( feof(f) ) break;
    evtrhoMap[evt] = rho;
    lcount++;
    if( !(lcount%1000) ) cout << "."; flush(cout);
  }
  cout << " done" << endl;
}

//----------------------------------------------------------------------------
unsigned makePFnoPUArray(mithep::Array<PFCandidate> * fPFCandidates,
                     vector<bool> &pfNoPileUpflag,
                     const mithep::VertexCol      * vtxArr )
//----------------------------------------------------------------------------
{
  for(UInt_t i = 0; i < fPFCandidates->GetEntries(); i++) {
    const PFCandidate *pf = fPFCandidates->At(i);
    assert(pf);

    if(pf->PFType() == PFCandidate::eHadron) {
      if(pf->HasTrackerTrk() && 
         vtxArr->At(0)->HasTrack(pf->TrackerTrk()) &&
         vtxArr->At(0)->TrackWeight(pf->TrackerTrk()) > 0) {

        pfNoPileUpflag.push_back(1);

      } else { 

        Bool_t vertexFound = kFALSE;
        const Vertex *closestVtx = 0;
        Double_t dzmin = 10000;
        
        // loop over vertices
        for(UInt_t j = 0; j < vtxArr->GetEntries(); j++) {
          const Vertex *vtx = vtxArr->At(j);
          assert(vtx);
          
          if(pf->HasTrackerTrk() && 
             vtx->HasTrack(pf->TrackerTrk()) &&
             vtx->TrackWeight(pf->TrackerTrk()) > 0) {
            vertexFound = kTRUE;
            closestVtx = vtx;
            break;
          }
          Double_t dz = fabs(pf->SourceVertex().Z() - vtx->Z());
          if(dz < dzmin) {
            closestVtx = vtx;
            dzmin = dz;
          }
        }

        //      if(fCheckClosestZVertex) {
        if(1) {
          // Fallback: if track is not associated with any vertex,
          // associate it with the vertex closest in z
          if(vertexFound || closestVtx != vtxArr->At(0)) {
            //      pfPileUp->Add(pf);
            pfNoPileUpflag.push_back(0);
          } else {
            pfNoPileUpflag.push_back(1);
          }
        } else {
          if(vertexFound && closestVtx != vtxArr->At(0)) {
            //      pfPileUp->Add(pf);
            pfNoPileUpflag.push_back(0);
          } else {
            //      PFCandidate * pfNoPileUp->AddNew(); // Ridiculous but that's how it is
            pfNoPileUpflag.push_back(1);
          }
        }
      } //hadron & trk stuff
    } else { // hadron
      //      PFCandidate * ptr = pfNoPileUp->AddNew();
      pfNoPileUpflag.push_back(1);
    }
  } // Loop over PF candidates

  return pfNoPileUpflag.size();
}

Revision:	1.25
Committed:	Tue May 22 22:31:18 2012 UTC (12 years, 11 months ago) by anlevin
Content type:	text/plain
Branch:	MAIN
Changes since 1.24:	+8 -64 lines
Log Message:	made changes for new round of synchronization