HLTInfo.cc

Go to the documentation of this file.

#include <iostream>
#include <sstream>
#include <istream>
#include <fstream>
#include <iomanip>
#include <string>
#include <cmath>
#include <functional>
#include <cstdlib>
#include <cstring>

#include "HLTrigger/HLTanalyzers/interface/HLTInfo.h"
#include "FWCore/Common/interface/TriggerNames.h"

// L1 related
#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtUtils.h"

//static const bool useL1EventSetup(true);
//static const bool useL1GtTriggerMenuLite(false);

HLTInfo::HLTInfo() {

  //set parameter defaults 
  _Debug=false;
  _OR_BXes=false;
  UnpackBxInEvent=1;
}

void HLTInfo::beginRun(const edm::Run& run, const edm::EventSetup& c){ 


  bool changed(true);
  if (hltPrescaleProvider_->init(run,c,processName_,changed)) {
    // if init returns TRUE, initialisation has succeeded!
    if (changed) {
      // The HLT config has actually changed wrt the previous Run, hence rebook your
      // histograms or do anything else dependent on the revised HLT config
      std::cout << "Initalizing HLTConfigProvider"  << std::endl;
    }
  } else {
    // if init returns FALSE, initialisation has NOT succeeded, which indicates a problem
    // with the file and/or code and needs to be investigated!
    std::cout << " HLT config extraction failure with process name " << processName_ << std::endl;
    // In this case, all access methods will return empty values!
  }

  

}

/*  Setup the analysis to put the branch-variables into the tree. */
void HLTInfo::setup(const edm::ParameterSet& pSet, TTree* HltTree) {

  processName_ = pSet.getParameter<std::string>("HLTProcessName") ;

  edm::ParameterSet myHltParams = pSet.getParameter<edm::ParameterSet>("RunParameters") ;
  std::vector<std::string> parameterNames = myHltParams.getParameterNames() ;
  
  for (auto & parameterName : parameterNames){
    if ( parameterName == "Debug" ) _Debug =  myHltParams.getParameter<bool>( parameterName );
  }

  dummyBranches_ = pSet.getUntrackedParameter<std::vector<std::string> >("dummyBranches",std::vector<std::string>(0));

  HltEvtCnt = 0;
  const int kMaxTrigFlag = 10000;
  trigflag = new int[kMaxTrigFlag];
  trigPrescl = new int[kMaxTrigFlag];

  L1EvtCnt = 0;
  const int kMaxL1Flag = 10000;
  l1flag = new int[kMaxL1Flag];
  l1flag5Bx = new int[kMaxTrigFlag];
  l1Prescl = new int[kMaxL1Flag];

  l1techflag = new int[kMaxL1Flag];
  //  l1techflag5Bx = new int[kMaxTrigFlag];
  l1techPrescl = new int[kMaxTrigFlag];

  const int kMaxHLTPart = 10000;
  hltppt = new float[kMaxHLTPart];
  hltpeta = new float[kMaxHLTPart];

  algoBitToName = new TString[512];
  techBitToName = new TString[512];
  

}

/* **Analyze the event** */
void HLTInfo::analyze(const edm::Handle<edm::TriggerResults>                 & hltresults,
              const edm::Handle<GlobalAlgBlkBxCollection> & l1results,
              edm::EventSetup const& eventSetup,
              edm::Event const& iEvent,
                      TTree* HltTree) {

//   std::cout << " Beginning HLTInfo " << std::endl;

  if (hltresults.isValid()) {
    int ntrigs = hltresults->size();
    if (ntrigs==0){std::cout << "%HLTInfo -- No trigger name given in TriggerResults of the input " << std::endl;}

    edm::TriggerNames const& triggerNames = iEvent.triggerNames(*hltresults);

    // 1st event : Book as many branches as trigger paths provided in the input...
    if (HltEvtCnt==0){
      for (int itrig = 0; itrig != ntrigs; ++itrig) {
        TString trigName = triggerNames.triggerName(itrig);
        HltTree->Branch(trigName,trigflag+itrig,trigName+"/I");
        HltTree->Branch(trigName+"_Prescl",trigPrescl+itrig,trigName+"_Prescl/I");
      }

      int itdum = ntrigs;
      for (auto & dummyBranche : dummyBranches_) {
    TString trigName(dummyBranche.data());
    bool addThisBranch = true;
    for (int itrig = 0; itrig != ntrigs; ++itrig) {
      TString realTrigName = triggerNames.triggerName(itrig);
      if(trigName == realTrigName) addThisBranch = false;
    }
    if(addThisBranch){
      HltTree->Branch(trigName,trigflag+itdum,trigName+"/I");
      HltTree->Branch(trigName+"_Prescl",trigPrescl+itdum,trigName+"_Prescl/I");
      trigflag[itdum] = 0;
      trigPrescl[itdum] = 0;
      ++itdum;
    }
      }

      HltEvtCnt++;
    }
    // ...Fill the corresponding accepts in branch-variables

    //std::cout << "Number of prescale sets: " << hltConfig_.prescaleSize() << std::endl;
    //std::cout << "Number of HLT paths: " << hltConfig_.size() << std::endl;
    //int presclSet = hltConfig_.prescaleSet(iEvent, eventSetup);
    //std::cout<<"\tPrescale set number: "<< presclSet <<std::endl; 

    for (int itrig = 0; itrig != ntrigs; ++itrig){

      const std::string& trigName=triggerNames.triggerName(itrig);
      bool accept = hltresults->accept(itrig);

      //trigPrescl[itrig] = hltConfig_.prescaleValue(iEvent, eventSetup, trigName);
      trigPrescl[itrig] = hltPrescaleProvider_->prescaleValue(iEvent, eventSetup, trigName);


      if (accept){trigflag[itrig] = 1;}
      else {trigflag[itrig] = 0;}

      if (_Debug){
        if (_Debug) std::cout << "%HLTInfo --  Number of HLT Triggers: " << ntrigs << std::endl;
        std::cout << "%HLTInfo --  HLTTrigger(" << itrig << "): " << trigName << " = " << accept << std::endl;
      }
    }
  }
  else { if (_Debug) std::cout << "%HLTInfo -- No Trigger Result" << std::endl;}



  //==============L1 information=======================================

  // L1 Triggers from Menu
  L1GtUtils const& l1GtUtils = hltPrescaleProvider_->l1GtUtils();

  //  m_l1GtUtils.retrieveL1EventSetup(eventSetup);
  //m_l1GtUtils.getL1GtRunCache(iEvent,eventSetup,useL1EventSetup,useL1GtTriggerMenuLite);
  /*
  unsigned long long id = eventSetup.get<L1TUtmTriggerMenuRcd>().cacheIdentifier();
  
  if (id != cache_id_) {
    cache_id_ = id; 
  */
  edm::ESHandle<L1TUtmTriggerMenu> menu;
  eventSetup.get<L1TUtmTriggerMenuRcd>().get(menu);
  //std::map<std::string, L1TUtmAlgorithm> const & algorithmMap_ = &(menu->getAlgorithmMap());    
  /*
  // get the bit/name association
  for (auto const & keyval: menu->getAlgorithmMap()) {
    std::string const & name  = keyval.second.getName();
    unsigned int        index = keyval.second.getIndex();
    std::cerr << "bit: " << index << "\tname: " << name << std::endl;
  }
  */
    //} // end get menu

  int iErrorCode = -1;
  L1GtUtils::TriggerCategory trigCategory = L1GtUtils::AlgorithmTrigger;
  const int pfSetIndexAlgorithmTrigger = l1GtUtils.prescaleFactorSetIndex(
                                      iEvent, trigCategory, iErrorCode);
  if (iErrorCode == 0) {
    if (_Debug) std::cout << "%Prescale set index: " << pfSetIndexAlgorithmTrigger  << std::endl;
  }else{
    std::cout << "%Could not extract Prescale set index from event record. Error code: " << iErrorCode << std::endl;
  }

  // 1st event : Book as many branches as trigger paths provided in the input...
  if (l1results.isValid()) {  
    
    int ntrigs = l1results->size();
    if (ntrigs==0){std::cout << "%L1Results -- No trigger name given in TriggerResults of the input " << std::endl;}
    /*
    edm::TriggerNames const& triggerNames = iEvent.triggerNames(&results);
    // 1st event : Book as many branches as trigger paths provided in the input...
    */
    if (L1EvtCnt==0){

      // get the bit/name association         
      for (auto const & keyval: menu->getAlgorithmMap()) { 
    std::string const & trigName  = keyval.second.getName(); 
    unsigned int index = keyval.second.getIndex(); 
    if (_Debug) std::cerr << "bit: " << index << "\tname: " << trigName << std::endl;                                                              
      
    int itrig = index;
    algoBitToName[itrig] = TString( trigName );
    
    TString l1trigName = static_cast<const char *>(algoBitToName[itrig]);
    std::string l1triggername = static_cast<const char *>(algoBitToName[itrig]);

    HltTree->Branch(l1trigName,l1flag+itrig,l1trigName+"/I");                    
        HltTree->Branch(l1trigName+"_Prescl",l1Prescl+itrig,l1trigName+"_Prescl/I"); 

      } // end algo Map

      L1EvtCnt++;     
    } // end l1evtCnt=0
  
    GlobalAlgBlk const &result = l1results->at(0, 0);

    // get the individual decisions from the GlobalAlgBlk
    for (unsigned int itrig = 0; itrig < result.maxPhysicsTriggers; ++itrig) {
       //      std::cerr << "bit: " << itrig << "\tresult: " << results.getAlgoDecisionFinal(itrig) << std::endl;

      bool myflag = result.getAlgoDecisionFinal(itrig) ; 
      if (myflag ) { l1flag[itrig] = 1; }
      else {l1flag[itrig] =0 ; }

      std::string l1triggername = static_cast<const char *>(algoBitToName[itrig]);
      l1Prescl[itrig] = l1GtUtils.prescaleFactor(iEvent, 
                         l1triggername, 
                         iErrorCode);      

      if (_Debug) std::cout << "L1 TD: "<<itrig<<" "<<algoBitToName[itrig]<<" " 
                << l1flag[itrig] <<" " 
                << l1Prescl[itrig] << std::endl;           
    }

    //    L1EvtCnt++;
    if (_Debug) std::cout << "%L1Info -- Done with routine" << std::endl;                                                                         

  } // l1results.isValid
  else { if (_Debug) std::cout << "%L1Results -- No Trigger Result" << std::endl;}                                                                             

}