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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 27 of file TriggerObjectTableProducer.cc.

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 29 of file TriggerObjectTableProducer.cc.

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

                                                                             :
             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>();
         }

TriggerObjectTableProducer::~TriggerObjectTableProducer ( )

inlineoverride

Definition at line 56 of file TriggerObjectTableProducer.cc.

References produce().

56 {}

Member Function Documentation

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

overrideprivate

Definition at line 113 of file TriggerObjectTableProducer.cc.

References funct::abs(), BXVector< T >::begin(), bits, bitsDoc_, DEFINE_FWK_MODULE, reco::deltaR2(), MillePedeFileConverter_cfg::e, BXVector< T >::end(), PVValHelper::eta, nanoaod::FlatTable::FloatColumn, edm::Event::getByToken(), mps_fire::i, TriggerObjectTableProducer::SelectedObject::id, idDoc_, createfilelist::int, nanoaod::FlatTable::IntColumn, L1Analysis::kMissingEt, L1Analysis::kMissingEtHF, L1Analysis::kMissingHt, L1Analysis::kMissingHtHF, L1Analysis::kTotalEt, L1Analysis::kTotalEtEm, L1Analysis::kTotalHt, L1Analysis::kTotalHtHF, triggerObjects_cff::l1EG, l1EG_, triggerObjects_cff::l1Jet, l1Jet_, triggerObjects_cff::l1Muon, l1Muon_, triggerObjects_cff::l1Sum, l1Sum_, triggerObjects_cff::l1Tau, l1Tau_, eostools::move(), name_, hgcalPlots::obj, phi, EnergyCorrector::pt, edm::Event::put(), SurveyInfoScenario_cff::seed, triggerObjects_cff::sel, sels_, pat::TriggerObject::setCollection(), TrackRefitter_38T_cff::src, src_, trigger::TriggerL1EG, trigger::TriggerL1ETM, trigger::TriggerL1ETT, trigger::TriggerL1HTM, trigger::TriggerL1HTT, trigger::TriggerL1Jet, trigger::TriggerL1Mu, and trigger::TriggerL1Tau.

Referenced by ~TriggerObjectTableProducer().

 {
 
     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)) {
                 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_, nanoaod::FlatTable::IntColumn);
     tab->addColumn<float>("pt", pt, "pt", nanoaod::FlatTable::FloatColumn, 12);
     tab->addColumn<float>("eta", eta, "eta", nanoaod::FlatTable::FloatColumn, 12);
     tab->addColumn<float>("phi", phi, "phi", nanoaod::FlatTable::FloatColumn, 12);
     tab->addColumn<float>("l1pt", l1pt, "pt of associated L1 seed", nanoaod::FlatTable::FloatColumn, 8);
     tab->addColumn<int>("l1iso", l1iso, "iso of associated L1 seed", nanoaod::FlatTable::IntColumn);
     tab->addColumn<int>("l1charge", l1charge, "charge of associated L1 seed", nanoaod::FlatTable::IntColumn);
     tab->addColumn<float>("l1pt_2", l1pt_2, "pt of associated secondary L1 seed", nanoaod::FlatTable::FloatColumn, 8);
     tab->addColumn<float>("l2pt", l2pt, "pt of associated 'L2' seed (i.e. HLT before tracking/PF)", nanoaod::FlatTable::FloatColumn, 10);
     tab->addColumn<int>("filterBits", bits, "extra bits of associated information: "+bitsDoc_, nanoaod::FlatTable::IntColumn);
     iEvent.put(std::move(tab));
 }