Inheritance diagram for TriggerObjectTableProducer:

Classes
struct	SelectedObject

Public Member Functions
	TriggerObjectTableProducer (const edm::ParameterSet &iConfig)

	~TriggerObjectTableProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	produce (edm::Event &, edm::EventSetup const &) override

Private Attributes
std::string	bitsDoc_

std::string	idDoc_

edm::EDGetTokenT< l1t::EGammaBxCollection >	l1EG_

edm::EDGetTokenT< l1t::JetBxCollection >	l1Jet_

edm::EDGetTokenT< l1t::MuonBxCollection >	l1Muon_

edm::EDGetTokenT< l1t::EtSumBxCollection >	l1Sum_

edm::EDGetTokenT< l1t::TauBxCollection >	l1Tau_

std::string	name_

std::vector< SelectedObject >	sels_

edm::EDGetTokenT< std::vector< pat::TriggerObjectStandAlone > >	src_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 27 of file TriggerObjectTableProducer.cc.

Constructor & Destructor Documentation

◆ TriggerObjectTableProducer()

TriggerObjectTableProducer::TriggerObjectTableProducer ( const edm::ParameterSet & iConfig )

inlineexplicit

Definition at line 29 of file TriggerObjectTableProducer.cc.

       : name_(iConfig.getParameter<std::string>("name")),
         src_(consumes<std::vector<pat::TriggerObjectStandAlone>>(iConfig.getParameter<edm::InputTag>("src"))),
         l1EG_(consumes<l1t::EGammaBxCollection>(iConfig.getParameter<edm::InputTag>("l1EG"))),
         l1Sum_(consumes<l1t::EtSumBxCollection>(iConfig.getParameter<edm::InputTag>("l1Sum"))),
         l1Jet_(consumes<l1t::JetBxCollection>(iConfig.getParameter<edm::InputTag>("l1Jet"))),
         l1Muon_(consumes<l1t::MuonBxCollection>(iConfig.getParameter<edm::InputTag>("l1Muon"))),
         l1Tau_(consumes<l1t::TauBxCollection>(iConfig.getParameter<edm::InputTag>("l1Tau"))) {
     std::vector<edm::ParameterSet> selPSets = iConfig.getParameter<std::vector<edm::ParameterSet>>("selections");
     sels_.reserve(selPSets.size());
     std::stringstream idstr, qualitystr;
     idstr << "ID of the object: ";
     for (auto &pset : selPSets) {
       sels_.emplace_back(pset);
       idstr << sels_.back().id << " = " << sels_.back().name;
       if (sels_.size() < selPSets.size())
         idstr << ", ";
       if (!sels_.back().qualityBitsDoc.empty()) {
         qualitystr << sels_.back().qualityBitsDoc << " for " << sels_.back().name << "; ";
       }
     }
     idDoc_ = idstr.str();
     bitsDoc_ = qualitystr.str();
  
     produces<nanoaod::FlatTable>();
   }

References bitsDoc_, edm::ParameterSet::getParameter(), idDoc_, muonDTDigis_cfi::pset, and sels_.

◆ ~TriggerObjectTableProducer()

TriggerObjectTableProducer::~TriggerObjectTableProducer ( )

inlineoverride

Definition at line 56 of file TriggerObjectTableProducer.cc.

56 {}

Member Function Documentation

◆ produce()

void TriggerObjectTableProducer::produce	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 115 of file TriggerObjectTableProducer.cc.

                                                                                       {
   edm::Handle<std::vector<pat::TriggerObjectStandAlone>> src;
   iEvent.getByToken(src_, src);
  
   std::vector<std::pair<const pat::TriggerObjectStandAlone *, const SelectedObject *>> selected;
   for (const auto &obj : *src) {
     for (const auto &sel : sels_) {
       if (sel.match(obj) && (sel.skipObjectsNotPassingQualityBits ? (int(sel.qualityBits(obj)) > 0) : true)) {
         selected.emplace_back(&obj, &sel);
         break;
       }
     }
   }
  
   // Self-cleaning
   std::map<const pat::TriggerObjectStandAlone *, int> selected_bits;
   for (unsigned int i = 0; i < selected.size(); ++i) {
     const auto &obj = *selected[i].first;
     const auto &sel = *selected[i].second;
     selected_bits[&obj] = int(sel.qualityBits(obj));
  
     for (unsigned int j = 0; j < i; ++j) {
       const auto &obj2 = *selected[j].first;
       const auto &sel2 = *selected[j].second;
       if (sel.id == sel2.id && abs(obj.pt() - obj2.pt()) < 1e-6 && deltaR2(obj, obj2) < 1e-6) {
         selected_bits[&obj2] |= selected_bits[&obj];  //Keep filters from all the objects
         selected.erase(selected.begin() + i);
         i--;
       }
     }
   }
  
   edm::Handle<l1t::EGammaBxCollection> l1EG;
   edm::Handle<l1t::EtSumBxCollection> l1Sum;
   edm::Handle<l1t::JetBxCollection> l1Jet;
   edm::Handle<l1t::MuonBxCollection> l1Muon;
   edm::Handle<l1t::TauBxCollection> l1Tau;
   iEvent.getByToken(l1EG_, l1EG);
   iEvent.getByToken(l1Sum_, l1Sum);
   iEvent.getByToken(l1Jet_, l1Jet);
   iEvent.getByToken(l1Muon_, l1Muon);
   iEvent.getByToken(l1Tau_, l1Tau);
  
   std::vector<pair<pat::TriggerObjectStandAlone, int>> l1Objects;
  
   for (l1t::EGammaBxCollection::const_iterator it = l1EG->begin(0); it != l1EG->end(0); it++) {
     pat::TriggerObjectStandAlone l1obj(it->p4());
     l1obj.setCollection("L1EG");
     l1obj.addTriggerObjectType(trigger::TriggerL1EG);
     l1Objects.emplace_back(l1obj, it->hwIso());
   }
  
   for (l1t::EtSumBxCollection::const_iterator it = l1Sum->begin(0); it != l1Sum->end(0); it++) {
     pat::TriggerObjectStandAlone l1obj(it->p4());
  
     switch (it->getType()) {
       case l1t::EtSum::EtSumType::kMissingEt:
         l1obj.addTriggerObjectType(trigger::TriggerL1ETM);
         l1obj.setCollection("L1ETM");
         break;
  
       case l1t::EtSum::EtSumType::kMissingEtHF:
         l1obj.addTriggerObjectType(trigger::TriggerL1ETM);
         l1obj.setCollection("L1ETMHF");
         break;
  
       case l1t::EtSum::EtSumType::kTotalEt:
         l1obj.addTriggerObjectType(trigger::TriggerL1ETT);
         l1obj.setCollection("L1ETT");
         break;
  
       case l1t::EtSum::EtSumType::kTotalEtEm:
         l1obj.addTriggerObjectType(trigger::TriggerL1ETT);
         l1obj.setCollection("L1ETEm");
         break;
  
       case l1t::EtSum::EtSumType::kTotalHt:
         l1obj.addTriggerObjectType(trigger::TriggerL1HTT);
         l1obj.setCollection("L1HTT");
         break;
  
       case l1t::EtSum::EtSumType::kTotalHtHF:
         l1obj.addTriggerObjectType(trigger::TriggerL1HTT);
         l1obj.setCollection("L1HTTHF");
         break;
  
       case l1t::EtSum::EtSumType::kMissingHt:
         l1obj.addTriggerObjectType(trigger::TriggerL1HTM);
         l1obj.setCollection("L1HTM");
         break;
  
       case l1t::EtSum::EtSumType::kMissingHtHF:
         l1obj.addTriggerObjectType(trigger::TriggerL1HTM);
         l1obj.setCollection("L1HTMHF");
         break;
  
       default:
         continue;
     }
  
     l1Objects.emplace_back(l1obj, it->hwIso());
   }
  
   for (l1t::JetBxCollection::const_iterator it = l1Jet->begin(0); it != l1Jet->end(0); it++) {
     pat::TriggerObjectStandAlone l1obj(it->p4());
     l1obj.setCollection("L1Jet");
     l1obj.addTriggerObjectType(trigger::TriggerL1Jet);
     l1Objects.emplace_back(l1obj, it->hwIso());
   }
  
   for (l1t::MuonBxCollection::const_iterator it = l1Muon->begin(0); it != l1Muon->end(0); it++) {
     pat::TriggerObjectStandAlone l1obj(it->p4());
     l1obj.setCollection("L1Mu");
     l1obj.addTriggerObjectType(trigger::TriggerL1Mu);
     l1obj.setCharge(it->charge());
     l1Objects.emplace_back(l1obj, it->hwIso());
   }
  
   for (l1t::TauBxCollection::const_iterator it = l1Tau->begin(0); it != l1Tau->end(0); it++) {
     pat::TriggerObjectStandAlone l1obj(it->p4());
     l1obj.setCollection("L1Tau");
     l1obj.addTriggerObjectType(trigger::TriggerL1Tau);
     l1Objects.emplace_back(l1obj, it->hwIso());
   }
  
   unsigned int nobj = selected.size();
   std::vector<float> pt(nobj, 0), eta(nobj, 0), phi(nobj, 0), l1pt(nobj, 0), l1pt_2(nobj, 0), l2pt(nobj, 0);
   std::vector<int> id(nobj, 0), bits(nobj, 0), l1iso(nobj, 0), l1charge(nobj, 0);
   for (unsigned int i = 0; i < nobj; ++i) {
     const auto &obj = *selected[i].first;
     const auto &sel = *selected[i].second;
     pt[i] = obj.pt();
     eta[i] = obj.eta();
     phi[i] = obj.phi();
     id[i] = sel.id;
     bits[i] = selected_bits[&obj];
     if (sel.l1DR2 > 0) {
       float best = sel.l1DR2;
       for (const auto &l1obj : l1Objects) {
         const auto &seed = l1obj.first;
         float dr2 = deltaR2(seed, obj);
         if (dr2 < best && sel.l1cut(seed)) {
           l1pt[i] = seed.pt();
           l1iso[i] = l1obj.second;
           l1charge[i] = seed.charge();
         }
       }
     }
     if (sel.l1DR2_2 > 0) {
       float best = sel.l1DR2_2;
       for (const auto &l1obj : l1Objects) {
         const auto &seed = l1obj.first;
         float dr2 = deltaR2(seed, obj);
         if (dr2 < best && sel.l1cut_2(seed)) {
           l1pt_2[i] = seed.pt();
         }
       }
     }
     if (sel.l2DR2 > 0) {
       float best = sel.l2DR2;
       for (const auto &seed : *src) {
         float dr2 = deltaR2(seed, obj);
         if (dr2 < best && sel.l2cut(seed)) {
           l2pt[i] = seed.pt();
         }
       }
     }
   }
  
   auto tab = std::make_unique<nanoaod::FlatTable>(nobj, name_, false, false);
   tab->addColumn<int>("id", id, idDoc_);
   tab->addColumn<float>("pt", pt, "pt", 12);
   tab->addColumn<float>("eta", eta, "eta", 12);
   tab->addColumn<float>("phi", phi, "phi", 12);
   tab->addColumn<float>("l1pt", l1pt, "pt of associated L1 seed", 8);
   tab->addColumn<int>("l1iso", l1iso, "iso of associated L1 seed");
   tab->addColumn<int>("l1charge", l1charge, "charge of associated L1 seed");
   tab->addColumn<float>("l1pt_2", l1pt_2, "pt of associated secondary L1 seed", 8);
   tab->addColumn<float>("l2pt", l2pt, "pt of associated 'L2' seed (i.e. HLT before tracking/PF)", 10);
   tab->addColumn<int>("filterBits", bits, "extra bits of associated information: " + bitsDoc_);
   iEvent.put(std::move(tab));
 }