HLTJetCollectionsForElePlusJets.cc

Go to the documentation of this file.

#include <string>
#include <vector>
 
#include "TVector3.h"
 
#include "FWCore/Framework/interface/MakerMacros.h"
#include "DataFormats/RecoCandidate/interface/RecoEcalCandidate.h"
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "HLTrigger/JetMET/interface/HLTJetCollectionsForElePlusJets.h"
#include "HLTrigger/HLTcore/interface/defaultModuleLabel.h"
 
template <typename T>
HLTJetCollectionsForElePlusJets<T>::HLTJetCollectionsForElePlusJets(const edm::ParameterSet& iConfig)
    : hltElectronTag(iConfig.getParameter<edm::InputTag>("HltElectronTag")),
      sourceJetTag(iConfig.getParameter<edm::InputTag>("SourceJetTag")),
      //minJetPt_(iConfig.getParameter<double> ("MinJetPt")),
      //maxAbsJetEta_(iConfig.getParameter<double> ("MaxAbsJetEta")),
      //minNJets_(iConfig.getParameter<unsigned int> ("MinNJets")),
      minDeltaR_(iConfig.getParameter<double>("minDeltaR"))
//Only for VBF
//minSoftJetPt_(iConfig.getParameter< double > ("MinSoftJetPt")),
//minDeltaEta_(iConfig.getParameter< double > ("MinDeltaEta"))
{
  typedef std::vector<edm::RefVector<std::vector<T>, T, edm::refhelper::FindUsingAdvance<std::vector<T>, T>>>
      TCollectionVector;
  m_theElectronToken = consumes<trigger::TriggerFilterObjectWithRefs>(hltElectronTag);
  m_theJetToken = consumes<std::vector<T>>(sourceJetTag);
  produces<TCollectionVector>();
}
 
template <typename T>
HLTJetCollectionsForElePlusJets<T>::~HLTJetCollectionsForElePlusJets() {
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)
}
 
template <typename T>
void HLTJetCollectionsForElePlusJets<T>::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("HltElectronTag", edm::InputTag("triggerFilterObjectWithRefs"));
  desc.add<edm::InputTag>("SourceJetTag", edm::InputTag("jetCollection"));
  // desc.add<double> ("MinJetPt", 30.);
  // desc.add<double> ("MaxAbsJetEta", 2.6);
  // desc.add<unsigned int> ("MinNJets", 1);
  desc.add<double>("minDeltaR", 0.5);
  //Only for VBF
  // desc.add<double> ("MinSoftJetPt", 25.);
  //desc.add<double> ("MinDeltaEta", -1.);
  descriptions.add(defaultModuleLabel<HLTJetCollectionsForElePlusJets<T>>(), desc);
}
 
//
// member functions
//
 
// ------------ method called to produce the data  ------------
template <typename T>
void HLTJetCollectionsForElePlusJets<T>::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  using namespace edm;
  using namespace std;
 
  typedef vector<T> TCollection;
  typedef Ref<TCollection> TRef;
 
  typedef edm::RefVector<TCollection> TRefVector;
 
  typedef std::vector<edm::RefVector<std::vector<T>, T, edm::refhelper::FindUsingAdvance<std::vector<T>, T>>>
      TCollectionVector;
 
  edm::Handle<trigger::TriggerFilterObjectWithRefs> PrevFilterOutput;
  iEvent.getByToken(m_theElectronToken, PrevFilterOutput);
 
  //its easier on the if statement flow if I try everything at once, shouldnt add to timing
  // Electrons can be stored as objects of types TriggerCluster, TriggerElectron, or TriggerPhoton
  std::vector<edm::Ref<reco::RecoEcalCandidateCollection>> clusCands;
  PrevFilterOutput->getObjects(trigger::TriggerCluster, clusCands);
 
  std::vector<edm::Ref<reco::ElectronCollection>> eleCands;
  PrevFilterOutput->getObjects(trigger::TriggerElectron, eleCands);
 
  trigger::VRphoton photonCands;
  PrevFilterOutput->getObjects(trigger::TriggerPhoton, photonCands);
 
  //prepare the collection of 3-D vector for electron momenta
  std::vector<TVector3> ElePs;
 
  if (!clusCands.empty()) {  //try trigger cluster
    for (auto& clusCand : clusCands) {
      TVector3 positionVector(clusCand->superCluster()->position().x(),
                              clusCand->superCluster()->position().y(),
                              clusCand->superCluster()->position().z());
      ElePs.push_back(positionVector);
    }
  } else if (!eleCands.empty()) {  // try trigger electrons
    for (auto& eleCand : eleCands) {
      TVector3 positionVector(eleCand->superCluster()->position().x(),
                              eleCand->superCluster()->position().y(),
                              eleCand->superCluster()->position().z());
      ElePs.push_back(positionVector);
    }
  } else if (!photonCands.empty()) {  // try trigger photons
    for (auto& photonCand : photonCands) {
      TVector3 positionVector(photonCand->superCluster()->position().x(),
                              photonCand->superCluster()->position().y(),
                              photonCand->superCluster()->position().z());
      ElePs.push_back(positionVector);
    }
  }
 
  edm::Handle<TCollection> theJetCollectionHandle;
  iEvent.getByToken(m_theJetToken, theJetCollectionHandle);
 
  const TCollection& theJetCollection = *theJetCollectionHandle;
 
  //std::unique_ptr< TCollection >  theFilteredJetCollection(new TCollection);
 
  std::unique_ptr<TCollectionVector> allSelections(new TCollectionVector());
 
  //bool foundSolution(false);
 
  for (auto& EleP : ElePs) {
    // bool VBFJetPair = false;
    //std::vector<int> store_jet;
    TRefVector refVector;
 
    for (unsigned int j = 0; j < theJetCollection.size(); j++) {
      TVector3 JetP(theJetCollection[j].px(), theJetCollection[j].py(), theJetCollection[j].pz());
      double DR = EleP.DeltaR(JetP);
 
      if (DR > minDeltaR_)
        refVector.push_back(TRef(theJetCollectionHandle, j));
    }
    allSelections->push_back(refVector);
  }
 
  //iEvent.put(std::move(theFilteredJetCollection));
  iEvent.put(std::move(allSelections));
 
  return;
}