/data/refman/pasoursint/CMSSW_4_1_8_patch9/src/DQM/HLTEvF/plugins/HLTTauDQMSource.cc

Go to the documentation of this file.

#include "DQM/HLTEvF/interface/HLTTauDQMSource.h"


//
// constructors and destructor
//
HLTTauDQMSource::HLTTauDQMSource( const edm::ParameterSet& ps ) :counterEvt_(0)
{

  //Get General Monitoring Parameters
  config_                 = ps.getParameter<std::vector<edm::ParameterSet> >("MonitorSetup");
  configType_             = ps.getParameter<std::vector<std::string> >("ConfigType");
  doRefAnalysis_          = ps.getParameter<bool>("doMatching");
  NPtBins_                = ps.getUntrackedParameter<int>("PtHistoBins",20);
  NEtaBins_               = ps.getUntrackedParameter<int>("EtaHistoBins",20);
  NPhiBins_               = ps.getUntrackedParameter<int>("PhiHistoBins",32);
  EtMax_                  = ps.getUntrackedParameter<double>("EtHistoMax",100);
  L1MatchDr_              = ps.getUntrackedParameter<double>("L1MatchDeltaR",0.5);
  HLTMatchDr_             = ps.getUntrackedParameter<double>("HLTMatchDeltaR",0.3);

  refFilter_              = ps.getUntrackedParameter<std::vector<edm::InputTag> >("matchFilter");
  refID_                  = ps.getUntrackedParameter<std::vector<int> >("matchObjectID");
  ptThres_                = ps.getUntrackedParameter<std::vector<double> >("matchObjectMinPt");
  prescaleEvt_            = ps.getUntrackedParameter<int>("prescaleEvt", -1);

  triggerEvent_           = ps.getParameter < edm::InputTag > ("TriggerEvent");

  //Read The Configuration
  for(unsigned int i=0;i<config_.size();++i)
    {

      if(configType_[i] == "L1")
        {
          HLTTauDQML1Plotter tmp(config_[i],NPtBins_,NEtaBins_,NPhiBins_,EtMax_,doRefAnalysis_,L1MatchDr_);
          l1Plotters.push_back(tmp);
        }

      if(configType_[i] == "Calo")
        {
          HLTTauDQMCaloPlotter tmp(config_[i],NPtBins_,NEtaBins_,NPhiBins_,EtMax_,doRefAnalysis_,HLTMatchDr_);
          caloPlotters.push_back(tmp);
        }

      else if(configType_[i] == "Track")
        {
          HLTTauDQMTrkPlotter tmp(config_[i],NPtBins_,NEtaBins_,NPhiBins_,EtMax_,doRefAnalysis_,HLTMatchDr_);
          trackPlotters.push_back(tmp);
        }

      else if(configType_[i] == "Path")
        {
          HLTTauDQMPathPlotter tmp(config_[i],doRefAnalysis_);
          pathPlotters.push_back(tmp);
        }

      else if(configType_[i] == "LitePath")
        {
          HLTTauDQMLitePathPlotter tmp(config_[i],NPtBins_,NEtaBins_,NPhiBins_,EtMax_,doRefAnalysis_,HLTMatchDr_);
          litePathPlotters.push_back(tmp);
        }


      else if(configType_[i] == "Summary")
        {
          HLTTauDQMSummaryPlotter tmp(config_[i]);
          summaryPlotters.push_back(tmp);
        }


    }
}

HLTTauDQMSource::~HLTTauDQMSource()
{
   
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)
  
}


//--------------------------------------------------------
void 
HLTTauDQMSource::beginJob(){

}

//--------------------------------------------------------
void HLTTauDQMSource::beginRun(const edm::Run& r, const edm::EventSetup& context) {

}

//--------------------------------------------------------
void HLTTauDQMSource::beginLuminosityBlock(const edm::LuminosityBlock& lumiSeg, 
                                           const edm::EventSetup& context) {
  
}

// ----------------------------------------------------------
void 
HLTTauDQMSource::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup )
{  
  using namespace std;
  using namespace edm;
  using namespace reco;
  using namespace l1extra;
  using namespace trigger;


  //Apply the prescaler
  if(counterEvt_ > prescaleEvt_)
    {
      //Do Analysis here
      
      //Create dummy Match Collections
      std::vector<LVColl> refC;

      if(doRefAnalysis_)
        {
          Handle<TriggerEvent> trigEv;

          //get The triggerEvent
          bool gotTEV =true;
          try {
             gotTEV*= iEvent.getByLabel(triggerEvent_,trigEv);
              }
          catch (cms::Exception& exception) {
            gotTEV =false;
          }



            if(gotTEV)
              for(unsigned int i=0;i<refFilter_.size();++i)
                {
                  size_t ID =trigEv->filterIndex(refFilter_[i]);
                  refC.push_back(getFilterCollection(ID,refID_[i],*trigEv,ptThres_[i]));
                }
        }

      //fill the empty slots with empty collections
      LVColl dummy;
      for(int k=refFilter_.size();k<3;k++)
        {
          refC.push_back(dummy);
        }

     
      
      //Path Plotters
      for(unsigned int i=0;i<pathPlotters.size();++i)
        pathPlotters[i].analyze(iEvent,iSetup,refC);

      //Lite Path Plotters
      for(unsigned int i=0;i<litePathPlotters.size();++i)
        litePathPlotters[i].analyze(iEvent,iSetup,refC);

      //L1  Plotters
      for(unsigned int i=0;i<l1Plotters.size();++i)
        l1Plotters[i].analyze(iEvent,iSetup,refC);

      //Calo Plotters
      for(unsigned int i=0;i<caloPlotters.size();++i)
        caloPlotters[i].analyze(iEvent,iSetup,refC[0]);

      //Track Plotters
      for(unsigned int i=0;i<trackPlotters.size();++i)
        trackPlotters[i].analyze(iEvent,iSetup,refC[0]);

    }
  else
      counterEvt_++;

}




//--------------------------------------------------------
void HLTTauDQMSource::endLuminosityBlock(const edm::LuminosityBlock& lumiSeg, 
                                         const edm::EventSetup& context) {
                                         
        //Summary Plotters
     for(unsigned int i=0;i<summaryPlotters.size();++i) summaryPlotters[i].plot();
     
}
//--------------------------------------------------------
void HLTTauDQMSource::endRun(const edm::Run& r, const edm::EventSetup& context){
}
//--------------------------------------------------------
void HLTTauDQMSource::endJob(){
  return;
}


LVColl 
HLTTauDQMSource::getFilterCollection(size_t index,int id,const trigger::TriggerEvent& trigEv,double ptCut)
{
  using namespace trigger;
  //Create output Collection
  LVColl out;
      //get All the final trigger objects
      const TriggerObjectCollection& TOC(trigEv.getObjects());

     
      //filter index
      if(index!=trigEv.sizeFilters())
        {
          const Keys& KEYS = trigEv.filterKeys(index);
          for(size_t i = 0;i<KEYS.size();++i)
            {
              const TriggerObject& TO(TOC[KEYS[i]]);
              LV a(TO.px(),TO.py(),TO.pz(),sqrt(TO.px()*TO.px()+TO.py()*TO.py()+TO.pz()*TO.pz()));
            if(abs(TO.id()) == id)
                if(a.pt()>ptCut)
                  out.push_back(a);
            }
        }
  return out;
}




//LVColl HLTTauDQMSource::getFilterCollection(size_t filterID,int id,const trigger::TriggerEventWithRefs& trigEv,double ptMin)
//{
//  using namespace trigger;
//
//  LVColl out;
//
//
//        if(id==trigger::TriggerL1IsoEG ||trigger::TriggerL1NoIsoEG) 
//          {
//            VRl1em obj;
//            trigEv.getObjects(filterID,id,obj);
//            for(size_t i=0;i<obj.size();++i)
//              if(&obj[i])
//                if(obj[i]->pt()>ptMin)
//                  out.push_back(obj[i]->p4());
//          }
//
//        if(id==trigger::TriggerL1Mu) 
//          {
//            VRl1muon obj;
//            trigEv.getObjects(filterID,id,obj);
//            for(size_t i=0;i<obj.size();++i)
//              if(&obj[i])
//                if(obj[i]->pt()>ptMin)
//                  out.push_back(obj[i]->p4());
//          }
//
//
//         if(id==trigger::TriggerMuon) 
//          {
//            VRmuon obj;
//            trigEv.getObjects(filterID,id,obj);
//            for(size_t i=0;i<obj.size();++i)
//              if(&obj[i])
//        if(obj[i]->pt()>ptMin)
//                  out.push_back(obj[i]->p4());
//          }
//
//        if(id==trigger::TriggerElectron) 
//          {
//            VRelectron obj;
//            trigEv.getObjects(filterID,id,obj);
//            for(size_t i=0;i<obj.size();++i)
//              if(&obj[i])
//                if(obj[i]->pt()>ptMin)
//                  out.push_back(obj[i]->p4());
//          }

//        if(id==trigger::TriggerL1TauJet) 
//          {
//            VRl1jet obj;
//            trigEv.getObjects(filterID,id,obj);
//            for(size_t i=0;i<obj.size();++i)
//              if(&obj[i])
//                if(obj[i]->pt()>ptMin)
//                  out.push_back(obj[i]->p4());
//          }

//        if(id==trigger::TriggerTau) 
//          {
//            VRjet obj;
//            trigEv.getObjects(filterID,id,obj);
//            for(size_t i=0;i<obj.size();++i)
//              if(&obj[i])
//                if(obj[i]->pt()>ptMin)
//                  out.push_back(obj[i]->p4());
//          }

//        return out;
//