HLTFiltCand.cc

Go to the documentation of this file.

#include "HLTFiltCand.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"

#include "DataFormats/Common/interface/Handle.h"

#include "DataFormats/RecoCandidate/interface/RecoEcalCandidate.h"
#include "DataFormats/RecoCandidate/interface/RecoEcalCandidateFwd.h"
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
#include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
#include "DataFormats/RecoCandidate/interface/RecoChargedCandidateFwd.h"
#include "DataFormats/JetReco/interface/CaloJet.h"
#include "DataFormats/JetReco/interface/CaloJetCollection.h"
#include "DataFormats/Candidate/interface/CompositeCandidate.h"
#include "DataFormats/Candidate/interface/CompositeCandidateFwd.h"
#include "DataFormats/METReco/interface/CaloMET.h"
#include "DataFormats/METReco/interface/CaloMETFwd.h"
#include "DataFormats/METReco/interface/MET.h"
#include "DataFormats/METReco/interface/METFwd.h"

#include "DataFormats/JetReco/interface/GenJet.h"
#include "DataFormats/JetReco/interface/GenJetCollection.h"
#include "DataFormats/METReco/interface/GenMET.h"
#include "DataFormats/METReco/interface/GenMETCollection.h"

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/HLTReco/interface/TriggerFilterObjectWithRefs.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

//
// constructors and destructor
//

HLTFiltCand::HLTFiltCand(const edm::ParameterSet& iConfig) : HLTFilter(iConfig),
  photTag_ (iConfig.getParameter<edm::InputTag>("photTag")),
  elecTag_ (iConfig.getParameter<edm::InputTag>("elecTag")),
  muonTag_ (iConfig.getParameter<edm::InputTag>("muonTag")),
  tausTag_ (iConfig.getParameter<edm::InputTag>("tausTag")),
  jetsTag_ (iConfig.getParameter<edm::InputTag>("jetsTag")),
  metsTag_ (iConfig.getParameter<edm::InputTag>("metsTag")),
  mhtsTag_ (iConfig.getParameter<edm::InputTag>("mhtsTag")),
  trckTag_ (iConfig.getParameter<edm::InputTag>("trckTag")),
  ecalTag_ (iConfig.getParameter<edm::InputTag>("ecalTag")),
  photToken_ (consumes<reco::RecoEcalCandidateCollection>   (photTag_)),
  elecToken_ (consumes<reco::ElectronCollection>            (elecTag_)),
  muonToken_ (consumes<reco::RecoChargedCandidateCollection>(muonTag_)),
  tausToken_ (consumes<reco::CaloJetCollection>             (tausTag_)),
  jetsToken_ (consumes<reco::CaloJetCollection>             (jetsTag_)),
  metsToken_ (consumes<reco::CaloMETCollection>             (metsTag_)),
  mhtsToken_ (consumes<reco::METCollection>                 (mhtsTag_)),
  trckToken_ (consumes<reco::RecoChargedCandidateCollection>(trckTag_)),
  ecalToken_ (consumes<reco::RecoEcalCandidateCollection>   (ecalTag_)),
  min_Pt_  (iConfig.getParameter<double>("MinPt"))
{
  LogDebug("") << "MinPt cut " << min_Pt_
   << " g: " << photTag_.encode()
   << " e: " << elecTag_.encode()
   << " m: " << muonTag_.encode()
   << " t: " << tausTag_.encode()
   << " j: " << jetsTag_.encode()
   << " M: " << metsTag_.encode()
   << " H: " << mhtsTag_.encode()
   <<" TR: " << trckTag_.encode()
   <<" SC: " << ecalTag_.encode()
   ;
}

HLTFiltCand::~HLTFiltCand() = default;

//
// member functions
//

void
HLTFiltCand::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  makeHLTFilterDescription(desc);
  desc.add<edm::InputTag>("photTag",edm::InputTag("photCollection"));
  desc.add<edm::InputTag>("elecTag",edm::InputTag("elecCollection"));
  desc.add<edm::InputTag>("muonTag",edm::InputTag("muonCollection"));
  desc.add<edm::InputTag>("tausTag",edm::InputTag("tausCollection"));
  desc.add<edm::InputTag>("jetsTag",edm::InputTag("jetsCollection"));
  desc.add<edm::InputTag>("metsTag",edm::InputTag("metsCollection"));
  desc.add<edm::InputTag>("mhtsTag",edm::InputTag("mhtsCollection"));
  desc.add<edm::InputTag>("trckTag",edm::InputTag("trckCollection"));
  desc.add<edm::InputTag>("ecalTag",edm::InputTag("ecalCollection"));
  desc.add<double>("MinPt",-1.0);
  descriptions.add("hltFiltCand", desc);
}

// ------------ method called to produce the data  ------------
bool
HLTFiltCand::hltFilter(edm::Event& iEvent, const edm::EventSetup& iSetup, trigger::TriggerFilterObjectWithRefs & filterproduct) const
{
   using namespace std;
   using namespace edm;
   using namespace reco;
   using namespace trigger;

   // All HLT filters must create and fill an HLT filter object,
   // recording any reconstructed physics objects satisfying (or not)
   // this HLT filter, and place it in the Event.

   // The filter object
   if (saveTags()) {
     filterproduct.addCollectionTag(photTag_);
     filterproduct.addCollectionTag(elecTag_);
     filterproduct.addCollectionTag(muonTag_);
     filterproduct.addCollectionTag(tausTag_);
     filterproduct.addCollectionTag(jetsTag_);
     filterproduct.addCollectionTag(metsTag_);
     filterproduct.addCollectionTag(mhtsTag_);
     filterproduct.addCollectionTag(trckTag_);
     filterproduct.addCollectionTag(ecalTag_);
   }

   // Specific filter code

   // get hold of products from Event

   Handle<RecoEcalCandidateCollection>   photons;
   Handle<ElectronCollection> electrons;
   Handle<RecoChargedCandidateCollection>     muons;
   Handle<CaloJetCollection>  taus;
   Handle<CaloJetCollection>  jets;
   Handle<CaloMETCollection>  mets;
   Handle<METCollection>      mhts;
   Handle<RecoChargedCandidateCollection> trcks;
   Handle<RecoEcalCandidateCollection>    ecals;

   iEvent.getByToken(photToken_,photons  );
   iEvent.getByToken(elecToken_,electrons);
   iEvent.getByToken(muonToken_,muons    );
   iEvent.getByToken(tausToken_,taus     );
   iEvent.getByToken(jetsToken_,jets     );
   iEvent.getByToken(metsToken_,mets     );
   iEvent.getByToken(mhtsToken_,mhts     );
   iEvent.getByToken(trckToken_,trcks    );
   iEvent.getByToken(ecalToken_,ecals    );


   // look for at least one g,e,m,t,j,M,H,TR,SC above its pt cut

   // photons
   int nphot(0);
   auto aphot(photons->begin());
   auto ophot(photons->end());
   RecoEcalCandidateCollection::const_iterator iphot;
   for (iphot=aphot; iphot!=ophot; iphot++) {
     if (iphot->pt() >= min_Pt_) {
       nphot++;
       RecoEcalCandidateRef ref(RecoEcalCandidateRef(photons,distance(aphot,iphot)));
       filterproduct.addObject(TriggerPhoton,ref);
     }
   }

   // electrons
   int nelec(0);
   auto aelec(electrons->begin());
   auto oelec(electrons->end());
   ElectronCollection::const_iterator ielec;
   for (ielec=aelec; ielec!=oelec; ielec++) {
     if (ielec->pt() >= min_Pt_) {
       nelec++;
       ElectronRef ref(ElectronRef(electrons,distance(aelec,ielec)));
       filterproduct.addObject(-TriggerElectron,ref);
     }
   }

   // muon
   int nmuon(0);
   auto amuon(muons->begin());
   auto omuon(muons->end());
   RecoChargedCandidateCollection::const_iterator imuon;
   for (imuon=amuon; imuon!=omuon; imuon++) {
     if (imuon->pt() >= min_Pt_) {
       nmuon++;
       RecoChargedCandidateRef ref(RecoChargedCandidateRef(muons,distance(amuon,imuon)));
       filterproduct.addObject(TriggerMuon,ref);
     }
   }

   // taus (are stored as jets)
   int ntaus(0);
   auto ataus(taus->begin());
   auto otaus(taus->end());
   CaloJetCollection::const_iterator itaus;
   for (itaus=ataus; itaus!=otaus; itaus++) {
     if (itaus->pt() >= min_Pt_) {
       ntaus++;
       CaloJetRef ref(CaloJetRef(taus,distance(ataus,itaus)));
       filterproduct.addObject(-TriggerTau,ref);
     }
   }

   // jets
   int njets(0);
   auto ajets(jets->begin());
   auto ojets(jets->end());
   CaloJetCollection::const_iterator ijets;
   for (ijets=ajets; ijets!=ojets; ijets++) {
     if (ijets->pt() >= min_Pt_) {
       njets++;
       CaloJetRef ref(CaloJetRef(jets,distance(ajets,ijets)));
       filterproduct.addObject(TriggerJet,ref);
     }
   }

   // mets
   int nmets(0);
   auto amets(mets->begin());
   auto omets(mets->end());
   CaloMETCollection::const_iterator imets;
   for (imets=amets; imets!=omets; imets++) {
     if (imets->pt() >= min_Pt_) {
       nmets++;
       CaloMETRef ref(CaloMETRef(mets,distance(amets,imets)));
       filterproduct.addObject(TriggerMET,ref);
     }
   }

   // mhts
   int nmhts(0);
   auto amhts(mhts->begin());
   auto omhts(mhts->end());
   METCollection::const_iterator imhts;
   for (imhts=amhts; imhts!=omhts; imhts++) {
     if (imhts->pt() >= min_Pt_) {
       nmhts++;
       METRef ref(METRef(mhts,distance(amhts,imhts)));
       filterproduct.addObject(TriggerMHT,ref);
     }
   }

   // trcks
   int ntrck(0);
   auto atrcks(trcks->begin());
   auto otrcks(trcks->end());
   RecoChargedCandidateCollection::const_iterator itrcks;
   for (itrcks=atrcks; itrcks!=otrcks; itrcks++) {
     if (itrcks->pt() >= min_Pt_) {
       ntrck++;
       RecoChargedCandidateRef ref(RecoChargedCandidateRef(trcks,distance(atrcks,itrcks)));
       filterproduct.addObject(TriggerTrack,ref);
     }
   }

   // ecals
   int necal(0);
   auto aecals(ecals->begin());
   auto oecals(ecals->end());
   RecoEcalCandidateCollection::const_iterator iecals;
   for (iecals=aecals; iecals!=oecals; iecals++) {
     if (iecals->pt() >= min_Pt_) {
       necal++;
       RecoEcalCandidateRef ref(RecoEcalCandidateRef(ecals,distance(aecals,iecals)));
       filterproduct.addObject(TriggerCluster,ref);
     }
   }

   // error case
   // filterproduct.addObject(0,Ref<vector<int> >());

   // final filter decision:
   const bool accept ( (nphot>0) && (nelec>0) && (nmuon>0) && (ntaus>0) &&
               //   (njets>0) && (nmets>0) && (nmhts>=0) && (ntrck>0) && (necal>0) );
               (njets>0) && (nmets>0) && (ntrck>0) && (necal>0) );

   LogDebug("") << "Number of g/e/m/t/j/M/H/TR/SC objects accepted:"
        << " " << nphot
        << " " << nelec
        << " " << nmuon
        << " " << ntaus
        << " " << njets
        << " " << nmets
        << " " << nmhts
        << " " << ntrck
        << " " << necal
                ;

   // return with final filter decision
   return accept;
}