Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2022-02-16 06:12:36 

0001 #ifndef HLTReco_TriggerRefsCollections_h
0002 #define HLTReco_TriggerRefsCollections_h
0003 
0004 /** \class trigger::TriggerRefsCollections
0005  *
0006  *  Holds the collections of Ref<C>s which describe the physics
0007  *  objects passing trigger cuts.
0008  *
0009  *  This implementation is not completely space-efficient as some
0010  *  physics object containers may stay empty. However, the big
0011  *  advantage is that the solution is generic, i.e., works for all
0012  *  possible HLT filters. Hence we accept the reasonably small
0013  *  overhead of empty containers.
0014  *
0015  *
0016  *  \author Martin Grunewald
0017  *
0018  */
0019 
0020 #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
0021 
0022 #include "DataFormats/Common/interface/Ref.h"
0023 #include "DataFormats/Common/interface/RefProd.h"
0024 
0025 #include "DataFormats/RecoCandidate/interface/RecoEcalCandidateFwd.h"
0026 #include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
0027 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidateFwd.h"
0028 #include "DataFormats/JetReco/interface/CaloJetCollection.h"
0029 #include "DataFormats/Candidate/interface/CompositeCandidateFwd.h"
0030 #include "DataFormats/METReco/interface/METFwd.h"
0031 #include "DataFormats/METReco/interface/CaloMETFwd.h"
0032 #include "DataFormats/METReco/interface/PFMETFwd.h"
0033 #include "DataFormats/HcalIsolatedTrack/interface/IsolatedPixelTrackCandidateFwd.h"
0034 
0035 #include "DataFormats/L1Trigger/interface/L1HFRingsFwd.h"         // deprecate
0036 #include "DataFormats/L1Trigger/interface/L1EmParticleFwd.h"      // deprecate
0037 #include "DataFormats/L1Trigger/interface/L1JetParticleFwd.h"     // deprecate
0038 #include "DataFormats/L1Trigger/interface/L1MuonParticleFwd.h"    // deprecate
0039 #include "DataFormats/L1Trigger/interface/L1EtMissParticleFwd.h"  // deprecate
0040 
0041 #include "DataFormats/L1Trigger/interface/Muon.h"
0042 #include "DataFormats/L1Trigger/interface/MuonShower.h"
0043 #include "DataFormats/L1Trigger/interface/EGamma.h"
0044 #include "DataFormats/L1Trigger/interface/Jet.h"
0045 #include "DataFormats/L1Trigger/interface/Tau.h"
0046 #include "DataFormats/L1Trigger/interface/EtSum.h"
0047 #include "DataFormats/L1TCorrelator/interface/TkMuon.h"
0048 #include "DataFormats/L1TCorrelator/interface/TkMuonFwd.h"
0049 #include "DataFormats/L1TCorrelator/interface/TkElectron.h"
0050 #include "DataFormats/L1TCorrelator/interface/TkElectronFwd.h"
0051 #include "DataFormats/L1TCorrelator/interface/TkEm.h"
0052 #include "DataFormats/L1TCorrelator/interface/TkEmFwd.h"
0053 #include "DataFormats/L1TParticleFlow/interface/PFJet.h"
0054 #include "DataFormats/L1TParticleFlow/interface/PFTau.h"
0055 #include "DataFormats/L1TParticleFlow/interface/HPSPFTau.h"
0056 #include "DataFormats/L1TParticleFlow/interface/HPSPFTauFwd.h"
0057 
0058 #include "DataFormats/JetReco/interface/PFJetCollection.h"
0059 #include "DataFormats/TauReco/interface/PFTauFwd.h"
0060 
0061 #include <cassert>
0062 #include <vector>
0063 
0064 #include <typeinfo>
0065 
0066 namespace trigger {
0067 
0068   typedef std::vector<reco::RecoEcalCandidateRef> VRphoton;
0069   typedef std::vector<reco::ElectronRef> VRelectron;
0070   typedef std::vector<reco::RecoChargedCandidateRef> VRmuon;
0071   typedef std::vector<reco::CaloJetRef> VRjet;
0072   typedef std::vector<reco::CompositeCandidateRef> VRcomposite;
0073   typedef std::vector<reco::METRef> VRbasemet;
0074   typedef std::vector<reco::CaloMETRef> VRcalomet;
0075   typedef std::vector<reco::IsolatedPixelTrackCandidateRef> VRpixtrack;
0076 
0077   typedef std::vector<l1extra::L1EmParticleRef> VRl1em;          //deprecate
0078   typedef std::vector<l1extra::L1MuonParticleRef> VRl1muon;      //deprecate
0079   typedef std::vector<l1extra::L1JetParticleRef> VRl1jet;        //deprecate
0080   typedef std::vector<l1extra::L1EtMissParticleRef> VRl1etmiss;  //deprecate
0081   typedef std::vector<l1extra::L1HFRingsRef> VRl1hfrings;        //deprecate
0082 
0083   typedef l1t::MuonVectorRef VRl1tmuon;
0084   typedef l1t::MuonShowerVectorRef VRl1tmuonShower;
0085   typedef l1t::EGammaVectorRef VRl1tegamma;
0086   typedef l1t::JetVectorRef VRl1tjet;
0087   typedef l1t::TauVectorRef VRl1ttau;
0088   typedef l1t::EtSumVectorRef VRl1tetsum;
0089 
0090   /* Phase-2 */
0091   typedef l1t::TkMuonVectorRef VRl1ttkmuon;
0092   typedef l1t::TkElectronVectorRef VRl1ttkele;
0093   typedef l1t::TkEmVectorRef VRl1ttkem;
0094   typedef l1t::PFJetVectorRef VRl1tpfjet;
0095   typedef l1t::HPSPFTauVectorRef VRl1thpspftau;
0096   typedef l1t::PFTauVectorRef VRl1tpftau;
0097   typedef l1t::PFTrackVectorRef VRl1tpftrack;
0098 
0099   typedef std::vector<reco::PFJetRef> VRpfjet;
0100   typedef std::vector<reco::PFTauRef> VRpftau;
0101   typedef std::vector<reco::PFMETRef> VRpfmet;
0102 
0103   class TriggerRefsCollections {
0104     /// data members
0105   private:
0106     /// physics type ids and Refs
0107     Vids photonIds_;
0108     VRphoton photonRefs_;
0109     Vids electronIds_;
0110     VRelectron electronRefs_;
0111     Vids muonIds_;
0112     VRmuon muonRefs_;
0113     Vids jetIds_;
0114     VRjet jetRefs_;
0115     Vids compositeIds_;
0116     VRcomposite compositeRefs_;
0117     Vids basemetIds_;
0118     VRbasemet basemetRefs_;
0119     Vids calometIds_;
0120     VRcalomet calometRefs_;
0121     Vids pixtrackIds_;
0122     VRpixtrack pixtrackRefs_;
0123 
0124     Vids l1emIds_;
0125     VRl1em l1emRefs_;
0126     Vids l1muonIds_;
0127     VRl1muon l1muonRefs_;
0128     Vids l1jetIds_;
0129     VRl1jet l1jetRefs_;
0130     Vids l1etmissIds_;
0131     VRl1etmiss l1etmissRefs_;
0132     Vids l1hfringsIds_;
0133     VRl1hfrings l1hfringsRefs_;
0134 
0135     Vids l1tmuonIds_;
0136     VRl1tmuon l1tmuonRefs_;
0137     Vids l1tmuonShowerIds_;
0138     VRl1tmuonShower l1tmuonShowerRefs_;
0139     Vids l1tegammaIds_;
0140     VRl1tegamma l1tegammaRefs_;
0141     Vids l1tjetIds_;
0142     VRl1tjet l1tjetRefs_;
0143     Vids l1ttauIds_;
0144     VRl1ttau l1ttauRefs_;
0145     Vids l1tetsumIds_;
0146     VRl1tetsum l1tetsumRefs_;
0147 
0148     /* Phase-2 */
0149     Vids l1ttkmuonIds_;
0150     VRl1ttkmuon l1ttkmuonRefs_;
0151     Vids l1ttkeleIds_;
0152     VRl1ttkele l1ttkeleRefs_;
0153     Vids l1ttkemIds_;
0154     VRl1ttkem l1ttkemRefs_;
0155     Vids l1tpfjetIds_;
0156     VRl1tpfjet l1tpfjetRefs_;
0157     Vids l1tpftauIds_;
0158     VRl1tpftau l1tpftauRefs_;
0159     Vids l1thpspftauIds_;
0160     VRl1thpspftau l1thpspftauRefs_;
0161     Vids l1tpftrackIds_;
0162     VRl1tpftrack l1tpftrackRefs_;
0163 
0164     Vids pfjetIds_;
0165     VRpfjet pfjetRefs_;
0166     Vids pftauIds_;
0167     VRpftau pftauRefs_;
0168     Vids pfmetIds_;
0169     VRpfmet pfmetRefs_;
0170 
0171     /// methods
0172   public:
0173     /// constructors
0174     TriggerRefsCollections()
0175         : photonIds_(),
0176           photonRefs_(),
0177           electronIds_(),
0178           electronRefs_(),
0179           muonIds_(),
0180           muonRefs_(),
0181           jetIds_(),
0182           jetRefs_(),
0183           compositeIds_(),
0184           compositeRefs_(),
0185           basemetIds_(),
0186           basemetRefs_(),
0187           calometIds_(),
0188           calometRefs_(),
0189           pixtrackIds_(),
0190           pixtrackRefs_(),
0191 
0192           l1emIds_(),
0193           l1emRefs_(),
0194           l1muonIds_(),
0195           l1muonRefs_(),
0196           l1jetIds_(),
0197           l1jetRefs_(),
0198           l1etmissIds_(),
0199           l1etmissRefs_(),
0200           l1hfringsIds_(),
0201           l1hfringsRefs_(),
0202 
0203           l1tmuonIds_(),
0204           l1tmuonRefs_(),
0205           l1tmuonShowerIds_(),
0206           l1tmuonShowerRefs_(),
0207           l1tegammaIds_(),
0208           l1tegammaRefs_(),
0209           l1tjetIds_(),
0210           l1tjetRefs_(),
0211           l1ttauIds_(),
0212           l1ttauRefs_(),
0213           l1tetsumIds_(),
0214           l1tetsumRefs_(),
0215 
0216           /* Phase-2 */
0217           l1ttkmuonIds_(),
0218           l1ttkmuonRefs_(),
0219           l1ttkeleIds_(),
0220           l1ttkeleRefs_(),
0221           l1ttkemIds_(),
0222           l1ttkemRefs_(),
0223           l1tpfjetIds_(),
0224           l1tpfjetRefs_(),
0225           l1tpftauIds_(),
0226           l1tpftauRefs_(),
0227           l1thpspftauIds_(),
0228           l1thpspftauRefs_(),
0229           l1tpftrackIds_(),
0230           l1tpftrackRefs_(),
0231 
0232           pfjetIds_(),
0233           pfjetRefs_(),
0234           pftauIds_(),
0235           pftauRefs_(),
0236           pfmetIds_(),
0237           pfmetRefs_() {}
0238 
0239     /// utility
0240     void swap(TriggerRefsCollections& other) {
0241       std::swap(photonIds_, other.photonIds_);
0242       std::swap(photonRefs_, other.photonRefs_);
0243       std::swap(electronIds_, other.electronIds_);
0244       std::swap(electronRefs_, other.electronRefs_);
0245       std::swap(muonIds_, other.muonIds_);
0246       std::swap(muonRefs_, other.muonRefs_);
0247       std::swap(jetIds_, other.jetIds_);
0248       std::swap(jetRefs_, other.jetRefs_);
0249       std::swap(compositeIds_, other.compositeIds_);
0250       std::swap(compositeRefs_, other.compositeRefs_);
0251       std::swap(basemetIds_, other.basemetIds_);
0252       std::swap(basemetRefs_, other.basemetRefs_);
0253       std::swap(calometIds_, other.calometIds_);
0254       std::swap(calometRefs_, other.calometRefs_);
0255       std::swap(pixtrackIds_, other.pixtrackIds_);
0256       std::swap(pixtrackRefs_, other.pixtrackRefs_);
0257 
0258       std::swap(l1emIds_, other.l1emIds_);
0259       std::swap(l1emRefs_, other.l1emRefs_);
0260       std::swap(l1muonIds_, other.l1muonIds_);
0261       std::swap(l1muonRefs_, other.l1muonRefs_);
0262       std::swap(l1jetIds_, other.l1jetIds_);
0263       std::swap(l1jetRefs_, other.l1jetRefs_);
0264       std::swap(l1etmissIds_, other.l1etmissIds_);
0265       std::swap(l1etmissRefs_, other.l1etmissRefs_);
0266       std::swap(l1hfringsIds_, other.l1hfringsIds_);
0267       std::swap(l1hfringsRefs_, other.l1hfringsRefs_);
0268 
0269       std::swap(l1tmuonIds_, other.l1tmuonIds_);
0270       std::swap(l1tmuonRefs_, other.l1tmuonRefs_);
0271       std::swap(l1tmuonShowerIds_, other.l1tmuonShowerIds_);
0272       std::swap(l1tmuonShowerRefs_, other.l1tmuonShowerRefs_);
0273       std::swap(l1tegammaIds_, other.l1tegammaIds_);
0274       std::swap(l1tegammaRefs_, other.l1tegammaRefs_);
0275       std::swap(l1tjetIds_, other.l1tjetIds_);
0276       std::swap(l1tjetRefs_, other.l1tjetRefs_);
0277       std::swap(l1ttauIds_, other.l1ttauIds_);
0278       std::swap(l1ttauRefs_, other.l1ttauRefs_);
0279       std::swap(l1tetsumIds_, other.l1tetsumIds_);
0280       std::swap(l1tetsumRefs_, other.l1tetsumRefs_);
0281 
0282       /* Phase-2 */
0283       std::swap(l1ttkmuonIds_, other.l1ttkmuonIds_);
0284       std::swap(l1ttkmuonRefs_, other.l1ttkmuonRefs_);
0285       std::swap(l1ttkeleIds_, other.l1ttkeleIds_);
0286       std::swap(l1ttkeleRefs_, other.l1ttkeleRefs_);
0287       std::swap(l1ttkemIds_, other.l1ttkemIds_);
0288       std::swap(l1ttkemRefs_, other.l1ttkemRefs_);
0289       std::swap(l1tpfjetIds_, other.l1tpfjetIds_);
0290       std::swap(l1tpfjetRefs_, other.l1tpfjetRefs_);
0291       std::swap(l1tpftauIds_, other.l1tpftauIds_);
0292       std::swap(l1tpftauRefs_, other.l1tpftauRefs_);
0293       std::swap(l1thpspftauIds_, other.l1thpspftauIds_);
0294       std::swap(l1thpspftauRefs_, other.l1thpspftauRefs_);
0295       std::swap(l1tpftrackIds_, other.l1tpftrackIds_);
0296       std::swap(l1tpftrackRefs_, other.l1tpftrackRefs_);
0297 
0298       std::swap(pfjetIds_, other.pfjetIds_);
0299       std::swap(pfjetRefs_, other.pfjetRefs_);
0300       std::swap(pftauIds_, other.pftauIds_);
0301       std::swap(pftauRefs_, other.pftauRefs_);
0302       std::swap(pfmetIds_, other.pfmetIds_);
0303       std::swap(pfmetRefs_, other.pfmetRefs_);
0304     }
0305 
0306     /// setters for L3 collections: (id=physics type, and Ref<C>)
0307     void addObject(int id, const reco::RecoEcalCandidateRef& ref) {
0308       photonIds_.push_back(id);
0309       photonRefs_.push_back(ref);
0310     }
0311     void addObject(int id, const reco::ElectronRef& ref) {
0312       electronIds_.push_back(id);
0313       electronRefs_.push_back(ref);
0314     }
0315     void addObject(int id, const reco::RecoChargedCandidateRef& ref) {
0316       muonIds_.push_back(id);
0317       muonRefs_.push_back(ref);
0318     }
0319     void addObject(int id, const reco::CaloJetRef& ref) {
0320       jetIds_.push_back(id);
0321       jetRefs_.push_back(ref);
0322     }
0323     void addObject(int id, const reco::CompositeCandidateRef& ref) {
0324       compositeIds_.push_back(id);
0325       compositeRefs_.push_back(ref);
0326     }
0327     void addObject(int id, const reco::METRef& ref) {
0328       basemetIds_.push_back(id);
0329       basemetRefs_.push_back(ref);
0330     }
0331     void addObject(int id, const reco::CaloMETRef& ref) {
0332       calometIds_.push_back(id);
0333       calometRefs_.push_back(ref);
0334     }
0335     void addObject(int id, const reco::IsolatedPixelTrackCandidateRef& ref) {
0336       pixtrackIds_.push_back(id);
0337       pixtrackRefs_.push_back(ref);
0338     }
0339 
0340     void addObject(int id, const l1extra::L1EmParticleRef& ref) {
0341       l1emIds_.push_back(id);
0342       l1emRefs_.push_back(ref);
0343     }
0344     void addObject(int id, const l1extra::L1MuonParticleRef& ref) {
0345       l1muonIds_.push_back(id);
0346       l1muonRefs_.push_back(ref);
0347     }
0348     void addObject(int id, const l1extra::L1JetParticleRef& ref) {
0349       l1jetIds_.push_back(id);
0350       l1jetRefs_.push_back(ref);
0351     }
0352     void addObject(int id, const l1extra::L1EtMissParticleRef& ref) {
0353       l1etmissIds_.push_back(id);
0354       l1etmissRefs_.push_back(ref);
0355     }
0356     void addObject(int id, const l1extra::L1HFRingsRef& ref) {
0357       l1hfringsIds_.push_back(id);
0358       l1hfringsRefs_.push_back(ref);
0359     }
0360     void addObject(int id, const l1t::MuonRef& ref) {
0361       l1tmuonIds_.push_back(id);
0362       l1tmuonRefs_.push_back(ref);
0363     }
0364     void addObject(int id, const l1t::MuonShowerRef& ref) {
0365       l1tmuonShowerIds_.push_back(id);
0366       l1tmuonShowerRefs_.push_back(ref);
0367     }
0368     void addObject(int id, const l1t::EGammaRef& ref) {
0369       l1tegammaIds_.push_back(id);
0370       l1tegammaRefs_.push_back(ref);
0371     }
0372     void addObject(int id, const l1t::JetRef& ref) {
0373       l1tjetIds_.push_back(id);
0374       l1tjetRefs_.push_back(ref);
0375     }
0376     void addObject(int id, const l1t::TauRef& ref) {
0377       l1ttauIds_.push_back(id);
0378       l1ttauRefs_.push_back(ref);
0379     }
0380     void addObject(int id, const l1t::EtSumRef& ref) {
0381       l1tetsumIds_.push_back(id);
0382       l1tetsumRefs_.push_back(ref);
0383     }
0384 
0385     /* Phase-2 */
0386     void addObject(int id, const l1t::TkMuonRef& ref) {
0387       l1ttkmuonIds_.push_back(id);
0388       l1ttkmuonRefs_.push_back(ref);
0389     }
0390     void addObject(int id, const l1t::TkElectronRef& ref) {
0391       l1ttkeleIds_.push_back(id);
0392       l1ttkeleRefs_.push_back(ref);
0393     }
0394     void addObject(int id, const l1t::TkEmRef& ref) {
0395       l1ttkemIds_.push_back(id);
0396       l1ttkemRefs_.push_back(ref);
0397     }
0398     void addObject(int id, const l1t::PFJetRef& ref) {
0399       l1tpfjetIds_.push_back(id);
0400       l1tpfjetRefs_.push_back(ref);
0401     }
0402     void addObject(int id, const l1t::PFTauRef& ref) {
0403       l1tpftauIds_.push_back(id);
0404       l1tpftauRefs_.push_back(ref);
0405     }
0406     void addObject(int id, const l1t::HPSPFTauRef& ref) {
0407       l1thpspftauIds_.push_back(id);
0408       l1thpspftauRefs_.push_back(ref);
0409     }
0410     void addObject(int id, const l1t::PFTrackRef& ref) {
0411       l1tpftrackIds_.push_back(id);
0412       l1tpftrackRefs_.push_back(ref);
0413     }
0414     void addObject(int id, const reco::PFJetRef& ref) {
0415       pfjetIds_.push_back(id);
0416       pfjetRefs_.push_back(ref);
0417     }
0418     void addObject(int id, const reco::PFTauRef& ref) {
0419       pftauIds_.push_back(id);
0420       pftauRefs_.push_back(ref);
0421     }
0422     void addObject(int id, const reco::PFMETRef& ref) {
0423       pfmetIds_.push_back(id);
0424       pfmetRefs_.push_back(ref);
0425     }
0426 
0427     ///
0428     size_type addObjects(const Vids& ids, const VRphoton& refs) {
0429       assert(ids.size() == refs.size());
0430       photonIds_.insert(photonIds_.end(), ids.begin(), ids.end());
0431       photonRefs_.insert(photonRefs_.end(), refs.begin(), refs.end());
0432       return photonIds_.size();
0433     }
0434     size_type addObjects(const Vids& ids, const VRelectron& refs) {
0435       assert(ids.size() == refs.size());
0436       electronIds_.insert(electronIds_.end(), ids.begin(), ids.end());
0437       electronRefs_.insert(electronRefs_.end(), refs.begin(), refs.end());
0438       return electronIds_.size();
0439     }
0440     size_type addObjects(const Vids& ids, const VRmuon& refs) {
0441       assert(ids.size() == refs.size());
0442       muonIds_.insert(muonIds_.end(), ids.begin(), ids.end());
0443       muonRefs_.insert(muonRefs_.end(), refs.begin(), refs.end());
0444       return muonIds_.size();
0445     }
0446     size_type addObjects(const Vids& ids, const VRjet& refs) {
0447       assert(ids.size() == refs.size());
0448       jetIds_.insert(jetIds_.end(), ids.begin(), ids.end());
0449       jetRefs_.insert(jetRefs_.end(), refs.begin(), refs.end());
0450       return jetIds_.size();
0451     }
0452     size_type addObjects(const Vids& ids, const VRcomposite& refs) {
0453       assert(ids.size() == refs.size());
0454       compositeIds_.insert(compositeIds_.end(), ids.begin(), ids.end());
0455       compositeRefs_.insert(compositeRefs_.end(), refs.begin(), refs.end());
0456       return compositeIds_.size();
0457     }
0458     size_type addObjects(const Vids& ids, const VRbasemet& refs) {
0459       assert(ids.size() == refs.size());
0460       basemetIds_.insert(basemetIds_.end(), ids.begin(), ids.end());
0461       basemetRefs_.insert(basemetRefs_.end(), refs.begin(), refs.end());
0462       return basemetIds_.size();
0463     }
0464     size_type addObjects(const Vids& ids, const VRcalomet& refs) {
0465       assert(ids.size() == refs.size());
0466       calometIds_.insert(calometIds_.end(), ids.begin(), ids.end());
0467       calometRefs_.insert(calometRefs_.end(), refs.begin(), refs.end());
0468       return calometIds_.size();
0469     }
0470     size_type addObjects(const Vids& ids, const VRpixtrack& refs) {
0471       assert(ids.size() == refs.size());
0472       pixtrackIds_.insert(pixtrackIds_.end(), ids.begin(), ids.end());
0473       pixtrackRefs_.insert(pixtrackRefs_.end(), refs.begin(), refs.end());
0474       return pixtrackIds_.size();
0475     }
0476 
0477     size_type addObjects(const Vids& ids, const VRl1em& refs) {
0478       assert(ids.size() == refs.size());
0479       l1emIds_.insert(l1emIds_.end(), ids.begin(), ids.end());
0480       l1emRefs_.insert(l1emRefs_.end(), refs.begin(), refs.end());
0481       return l1emIds_.size();
0482     }
0483     size_type addObjects(const Vids& ids, const VRl1muon& refs) {
0484       assert(ids.size() == refs.size());
0485       l1muonIds_.insert(l1muonIds_.end(), ids.begin(), ids.end());
0486       l1muonRefs_.insert(l1muonRefs_.end(), refs.begin(), refs.end());
0487       return l1muonIds_.size();
0488     }
0489     size_type addObjects(const Vids& ids, const VRl1jet& refs) {
0490       assert(ids.size() == refs.size());
0491       l1jetIds_.insert(l1jetIds_.end(), ids.begin(), ids.end());
0492       l1jetRefs_.insert(l1jetRefs_.end(), refs.begin(), refs.end());
0493       return l1jetIds_.size();
0494     }
0495     size_type addObjects(const Vids& ids, const VRl1etmiss& refs) {
0496       assert(ids.size() == refs.size());
0497       l1etmissIds_.insert(l1etmissIds_.end(), ids.begin(), ids.end());
0498       l1etmissRefs_.insert(l1etmissRefs_.end(), refs.begin(), refs.end());
0499       return l1etmissIds_.size();
0500     }
0501     size_type addObjects(const Vids& ids, const VRl1tmuon& refs) {
0502       assert(ids.size() == refs.size());
0503       l1tmuonIds_.insert(l1tmuonIds_.end(), ids.begin(), ids.end());
0504       l1tmuonRefs_.insert(l1tmuonRefs_.end(), refs.begin(), refs.end());
0505       return l1tmuonIds_.size();
0506     }
0507     size_type addObjects(const Vids& ids, const VRl1tmuonShower& refs) {
0508       assert(ids.size() == refs.size());
0509       l1tmuonShowerIds_.insert(l1tmuonShowerIds_.end(), ids.begin(), ids.end());
0510       l1tmuonShowerRefs_.insert(l1tmuonShowerRefs_.end(), refs.begin(), refs.end());
0511       return l1tmuonShowerIds_.size();
0512     }
0513     size_type addObjects(const Vids& ids, const VRl1tegamma& refs) {
0514       assert(ids.size() == refs.size());
0515       l1tegammaIds_.insert(l1tegammaIds_.end(), ids.begin(), ids.end());
0516       l1tegammaRefs_.insert(l1tegammaRefs_.end(), refs.begin(), refs.end());
0517       return l1tegammaIds_.size();
0518     }
0519     size_type addObjects(const Vids& ids, const VRl1tjet& refs) {
0520       assert(ids.size() == refs.size());
0521       l1tjetIds_.insert(l1tjetIds_.end(), ids.begin(), ids.end());
0522       l1tjetRefs_.insert(l1tjetRefs_.end(), refs.begin(), refs.end());
0523       return l1tjetIds_.size();
0524     }
0525     size_type addObjects(const Vids& ids, const VRl1ttau& refs) {
0526       assert(ids.size() == refs.size());
0527       l1ttauIds_.insert(l1ttauIds_.end(), ids.begin(), ids.end());
0528       l1ttauRefs_.insert(l1ttauRefs_.end(), refs.begin(), refs.end());
0529       return l1ttauIds_.size();
0530     }
0531     size_type addObjects(const Vids& ids, const VRl1tetsum& refs) {
0532       assert(ids.size() == refs.size());
0533       l1tetsumIds_.insert(l1tetsumIds_.end(), ids.begin(), ids.end());
0534       l1tetsumRefs_.insert(l1tetsumRefs_.end(), refs.begin(), refs.end());
0535       return l1tetsumIds_.size();
0536     }
0537     size_type addObjects(const Vids& ids, const VRl1hfrings& refs) {
0538       assert(ids.size() == refs.size());
0539       l1hfringsIds_.insert(l1hfringsIds_.end(), ids.begin(), ids.end());
0540       l1hfringsRefs_.insert(l1hfringsRefs_.end(), refs.begin(), refs.end());
0541       return l1hfringsIds_.size();
0542     }
0543 
0544     /* Phase-2 */
0545     size_type addObjects(const Vids& ids, const VRl1ttkmuon& refs) {
0546       assert(ids.size() == refs.size());
0547       l1ttkmuonIds_.insert(l1ttkmuonIds_.end(), ids.begin(), ids.end());
0548       l1ttkmuonRefs_.insert(l1ttkmuonRefs_.end(), refs.begin(), refs.end());
0549       return l1ttkmuonIds_.size();
0550     }
0551     size_type addObjects(const Vids& ids, const VRl1ttkele& refs) {
0552       assert(ids.size() == refs.size());
0553       l1ttkeleIds_.insert(l1ttkeleIds_.end(), ids.begin(), ids.end());
0554       l1ttkeleRefs_.insert(l1ttkeleRefs_.end(), refs.begin(), refs.end());
0555       return l1ttkeleIds_.size();
0556     }
0557     size_type addObjects(const Vids& ids, const VRl1ttkem& refs) {
0558       assert(ids.size() == refs.size());
0559       l1ttkemIds_.insert(l1ttkemIds_.end(), ids.begin(), ids.end());
0560       l1ttkemRefs_.insert(l1ttkemRefs_.end(), refs.begin(), refs.end());
0561       return l1ttkemIds_.size();
0562     }
0563     size_type addObjects(const Vids& ids, const VRl1tpfjet& refs) {
0564       assert(ids.size() == refs.size());
0565       l1tpfjetIds_.insert(l1tpfjetIds_.end(), ids.begin(), ids.end());
0566       l1tpfjetRefs_.insert(l1tpfjetRefs_.end(), refs.begin(), refs.end());
0567       return l1tpfjetIds_.size();
0568     }
0569     size_type addObjects(const Vids& ids, const VRl1tpftau& refs) {
0570       assert(ids.size() == refs.size());
0571       l1tpftauIds_.insert(l1tpftauIds_.end(), ids.begin(), ids.end());
0572       l1tpftauRefs_.insert(l1tpftauRefs_.end(), refs.begin(), refs.end());
0573       return l1tpftauIds_.size();
0574     }
0575     size_type addObjects(const Vids& ids, const VRl1thpspftau& refs) {
0576       assert(ids.size() == refs.size());
0577       l1thpspftauIds_.insert(l1thpspftauIds_.end(), ids.begin(), ids.end());
0578       l1thpspftauRefs_.insert(l1thpspftauRefs_.end(), refs.begin(), refs.end());
0579       return l1thpspftauIds_.size();
0580     }
0581     size_type addObjects(const Vids& ids, const VRl1tpftrack& refs) {
0582       assert(ids.size() == refs.size());
0583       l1tpftrackIds_.insert(l1tpftrackIds_.end(), ids.begin(), ids.end());
0584       l1tpftrackRefs_.insert(l1tpftrackRefs_.end(), refs.begin(), refs.end());
0585       return l1tpftrackIds_.size();
0586     }
0587 
0588     size_type addObjects(const Vids& ids, const VRpfjet& refs) {
0589       assert(ids.size() == refs.size());
0590       pfjetIds_.insert(pfjetIds_.end(), ids.begin(), ids.end());
0591       pfjetRefs_.insert(pfjetRefs_.end(), refs.begin(), refs.end());
0592       return pfjetIds_.size();
0593     }
0594     size_type addObjects(const Vids& ids, const VRpftau& refs) {
0595       assert(ids.size() == refs.size());
0596       pftauIds_.insert(pftauIds_.end(), ids.begin(), ids.end());
0597       pftauRefs_.insert(pftauRefs_.end(), refs.begin(), refs.end());
0598       return pftauIds_.size();
0599     }
0600     size_type addObjects(const Vids& ids, const VRpfmet& refs) {
0601       assert(ids.size() == refs.size());
0602       pfmetIds_.insert(pfmetIds_.end(), ids.begin(), ids.end());
0603       pfmetRefs_.insert(pfmetRefs_.end(), refs.begin(), refs.end());
0604       return pfmetIds_.size();
0605     }
0606 
0607     /// various physics-level getters:
0608     void getObjects(Vids& ids, VRphoton& refs) const { getObjects(ids, refs, 0, photonIds_.size()); }
0609     void getObjects(Vids& ids, VRphoton& refs, size_type begin, size_type end) const {
0610       assert(begin <= end);
0611       assert(end <= photonIds_.size());
0612       const size_type n(end - begin);
0613       ids.resize(n);
0614       refs.resize(n);
0615       size_type j(0);
0616       for (size_type i = begin; i != end; ++i) {
0617         ids[j] = photonIds_[i];
0618         refs[j] = photonRefs_[i];
0619         ++j;
0620       }
0621     }
0622     void getObjects(int id, VRphoton& refs) const { getObjects(id, refs, 0, photonIds_.size()); }
0623     void getObjects(int id, VRphoton& refs, size_type begin, size_type end) const {
0624       assert(begin <= end);
0625       assert(end <= photonIds_.size());
0626       size_type n(0);
0627       for (size_type i = begin; i != end; ++i) {
0628         if (id == photonIds_[i]) {
0629           ++n;
0630         }
0631       }
0632       refs.resize(n);
0633       size_type j(0);
0634       for (size_type i = begin; i != end; ++i) {
0635         if (id == photonIds_[i]) {
0636           refs[j] = photonRefs_[i];
0637           ++j;
0638         }
0639       }
0640       return;
0641     }
0642 
0643     void getObjects(Vids& ids, VRelectron& refs) const { getObjects(ids, refs, 0, electronIds_.size()); }
0644     void getObjects(Vids& ids, VRelectron& refs, size_type begin, size_type end) const {
0645       assert(begin <= end);
0646       assert(end <= electronIds_.size());
0647       const size_type n(end - begin);
0648       ids.resize(n);
0649       refs.resize(n);
0650       size_type j(0);
0651       for (size_type i = begin; i != end; ++i) {
0652         ids[j] = electronIds_[i];
0653         refs[j] = electronRefs_[i];
0654         ++j;
0655       }
0656     }
0657     void getObjects(int id, VRelectron& refs) const { getObjects(id, refs, 0, electronIds_.size()); }
0658     void getObjects(int id, VRelectron& refs, size_type begin, size_type end) const {
0659       assert(begin <= end);
0660       assert(end <= electronIds_.size());
0661       size_type n(0);
0662       for (size_type i = begin; i != end; ++i) {
0663         if (id == electronIds_[i]) {
0664           ++n;
0665         }
0666       }
0667       refs.resize(n);
0668       size_type j(0);
0669       for (size_type i = begin; i != end; ++i) {
0670         if (id == electronIds_[i]) {
0671           refs[j] = electronRefs_[i];
0672           ++j;
0673         }
0674       }
0675       return;
0676     }
0677 
0678     void getObjects(Vids& ids, VRmuon& refs) const { getObjects(ids, refs, 0, muonIds_.size()); }
0679     void getObjects(Vids& ids, VRmuon& refs, size_type begin, size_type end) const {
0680       assert(begin <= end);
0681       assert(end <= muonIds_.size());
0682       const size_type n(end - begin);
0683       ids.resize(n);
0684       refs.resize(n);
0685       size_type j(0);
0686       for (size_type i = begin; i != end; ++i) {
0687         ids[j] = muonIds_[i];
0688         refs[j] = muonRefs_[i];
0689         ++j;
0690       }
0691     }
0692     void getObjects(int id, VRmuon& refs) const { getObjects(id, refs, 0, muonIds_.size()); }
0693     void getObjects(int id, VRmuon& refs, size_type begin, size_type end) const {
0694       assert(begin <= end);
0695       assert(end <= muonIds_.size());
0696       size_type n(0);
0697       for (size_type i = begin; i != end; ++i) {
0698         if (id == muonIds_[i]) {
0699           ++n;
0700         }
0701       }
0702       refs.resize(n);
0703       size_type j(0);
0704       for (size_type i = begin; i != end; ++i) {
0705         if (id == muonIds_[i]) {
0706           refs[j] = muonRefs_[i];
0707           ++j;
0708         }
0709       }
0710       return;
0711     }
0712 
0713     void getObjects(Vids& ids, VRjet& refs) const { getObjects(ids, refs, 0, jetIds_.size()); }
0714     void getObjects(Vids& ids, VRjet& refs, size_type begin, size_type end) const {
0715       assert(begin <= end);
0716       assert(end <= jetIds_.size());
0717       const size_type n(end - begin);
0718       ids.resize(n);
0719       refs.resize(n);
0720       size_type j(0);
0721       for (size_type i = begin; i != end; ++i) {
0722         ids[j] = jetIds_[i];
0723         refs[j] = jetRefs_[i];
0724         ++j;
0725       }
0726     }
0727     void getObjects(int id, VRjet& refs) const { getObjects(id, refs, 0, jetIds_.size()); }
0728     void getObjects(int id, VRjet& refs, size_type begin, size_type end) const {
0729       assert(begin <= end);
0730       assert(end <= jetIds_.size());
0731       size_type n(0);
0732       for (size_type i = begin; i != end; ++i) {
0733         if (id == jetIds_[i]) {
0734           ++n;
0735         }
0736       }
0737       refs.resize(n);
0738       size_type j(0);
0739       for (size_type i = begin; i != end; ++i) {
0740         if (id == jetIds_[i]) {
0741           refs[j] = jetRefs_[i];
0742           ++j;
0743         }
0744       }
0745       return;
0746     }
0747 
0748     void getObjects(Vids& ids, VRcomposite& refs) const { getObjects(ids, refs, 0, compositeIds_.size()); }
0749     void getObjects(Vids& ids, VRcomposite& refs, size_type begin, size_type end) const {
0750       assert(begin <= end);
0751       assert(end <= compositeIds_.size());
0752       const size_type n(end - begin);
0753       ids.resize(n);
0754       refs.resize(n);
0755       size_type j(0);
0756       for (size_type i = begin; i != end; ++i) {
0757         ids[j] = compositeIds_[i];
0758         refs[j] = compositeRefs_[i];
0759         ++j;
0760       }
0761     }
0762     void getObjects(int id, VRcomposite& refs) const { getObjects(id, refs, 0, compositeIds_.size()); }
0763     void getObjects(int id, VRcomposite& refs, size_type begin, size_type end) const {
0764       assert(begin <= end);
0765       assert(end <= compositeIds_.size());
0766       size_type n(0);
0767       for (size_type i = begin; i != end; ++i) {
0768         if (id == compositeIds_[i]) {
0769           ++n;
0770         }
0771       }
0772       refs.resize(n);
0773       size_type j(0);
0774       for (size_type i = begin; i != end; ++i) {
0775         if (id == compositeIds_[i]) {
0776           refs[j] = compositeRefs_[i];
0777           ++j;
0778         }
0779       }
0780       return;
0781     }
0782 
0783     void getObjects(Vids& ids, VRbasemet& refs) const { getObjects(ids, refs, 0, basemetIds_.size()); }
0784     void getObjects(Vids& ids, VRbasemet& refs, size_type begin, size_type end) const {
0785       assert(begin <= end);
0786       assert(end <= basemetIds_.size());
0787       const size_type n(end - begin);
0788       ids.resize(n);
0789       refs.resize(n);
0790       size_type j(0);
0791       for (size_type i = begin; i != end; ++i) {
0792         ids[j] = basemetIds_[i];
0793         refs[j] = basemetRefs_[i];
0794         ++j;
0795       }
0796     }
0797     void getObjects(int id, VRbasemet& refs) const { getObjects(id, refs, 0, basemetIds_.size()); }
0798     void getObjects(int id, VRbasemet& refs, size_type begin, size_type end) const {
0799       assert(begin <= end);
0800       assert(end <= basemetIds_.size());
0801       size_type n(0);
0802       for (size_type i = begin; i != end; ++i) {
0803         if (id == basemetIds_[i]) {
0804           ++n;
0805         }
0806       }
0807       refs.resize(n);
0808       size_type j(0);
0809       for (size_type i = begin; i != end; ++i) {
0810         if (id == basemetIds_[i]) {
0811           refs[j] = basemetRefs_[i];
0812           ++j;
0813         }
0814       }
0815       return;
0816     }
0817 
0818     void getObjects(Vids& ids, VRcalomet& refs) const { getObjects(ids, refs, 0, calometIds_.size()); }
0819     void getObjects(Vids& ids, VRcalomet& refs, size_type begin, size_type end) const {
0820       assert(begin <= end);
0821       assert(end <= calometIds_.size());
0822       const size_type n(end - begin);
0823       ids.resize(n);
0824       refs.resize(n);
0825       size_type j(0);
0826       for (size_type i = begin; i != end; ++i) {
0827         ids[j] = calometIds_[i];
0828         refs[j] = calometRefs_[i];
0829         ++j;
0830       }
0831     }
0832     void getObjects(int id, VRcalomet& refs) const { getObjects(id, refs, 0, calometIds_.size()); }
0833     void getObjects(int id, VRcalomet& refs, size_type begin, size_type end) const {
0834       assert(begin <= end);
0835       assert(end <= calometIds_.size());
0836       size_type n(0);
0837       for (size_type i = begin; i != end; ++i) {
0838         if (id == calometIds_[i]) {
0839           ++n;
0840         }
0841       }
0842       refs.resize(n);
0843       size_type j(0);
0844       for (size_type i = begin; i != end; ++i) {
0845         if (id == calometIds_[i]) {
0846           refs[j] = calometRefs_[i];
0847           ++j;
0848         }
0849       }
0850       return;
0851     }
0852 
0853     void getObjects(Vids& ids, VRpixtrack& refs) const { getObjects(ids, refs, 0, pixtrackIds_.size()); }
0854     void getObjects(Vids& ids, VRpixtrack& refs, size_type begin, size_type end) const {
0855       assert(begin <= end);
0856       assert(end <= pixtrackIds_.size());
0857       const size_type n(end - begin);
0858       ids.resize(n);
0859       refs.resize(n);
0860       size_type j(0);
0861       for (size_type i = begin; i != end; ++i) {
0862         ids[j] = pixtrackIds_[i];
0863         refs[j] = pixtrackRefs_[i];
0864         ++j;
0865       }
0866     }
0867     void getObjects(int id, VRpixtrack& refs) const { getObjects(id, refs, 0, pixtrackIds_.size()); }
0868     void getObjects(int id, VRpixtrack& refs, size_type begin, size_type end) const {
0869       assert(begin <= end);
0870       assert(end <= pixtrackIds_.size());
0871       size_type n(0);
0872       for (size_type i = begin; i != end; ++i) {
0873         if (id == pixtrackIds_[i]) {
0874           ++n;
0875         }
0876       }
0877       refs.resize(n);
0878       size_type j(0);
0879       for (size_type i = begin; i != end; ++i) {
0880         if (id == pixtrackIds_[i]) {
0881           refs[j] = pixtrackRefs_[i];
0882           ++j;
0883         }
0884       }
0885       return;
0886     }
0887 
0888     void getObjects(Vids& ids, VRl1em& refs) const { getObjects(ids, refs, 0, l1emIds_.size()); }
0889     void getObjects(Vids& ids, VRl1em& refs, size_type begin, size_type end) const {
0890       assert(begin <= end);
0891       assert(end <= l1emIds_.size());
0892       const size_type n(end - begin);
0893       ids.resize(n);
0894       refs.resize(n);
0895       size_type j(0);
0896       for (size_type i = begin; i != end; ++i) {
0897         ids[j] = l1emIds_[i];
0898         refs[j] = l1emRefs_[i];
0899         ++j;
0900       }
0901     }
0902     void getObjects(int id, VRl1em& refs) const { getObjects(id, refs, 0, l1emIds_.size()); }
0903     void getObjects(int id, VRl1em& refs, size_type begin, size_type end) const {
0904       assert(begin <= end);
0905       assert(end <= l1emIds_.size());
0906       size_type n(0);
0907       for (size_type i = begin; i != end; ++i) {
0908         if (id == l1emIds_[i]) {
0909           ++n;
0910         }
0911       }
0912       refs.resize(n);
0913       size_type j(0);
0914       for (size_type i = begin; i != end; ++i) {
0915         if (id == l1emIds_[i]) {
0916           refs[j] = l1emRefs_[i];
0917           ++j;
0918         }
0919       }
0920       return;
0921     }
0922 
0923     void getObjects(Vids& ids, VRl1muon& refs) const { getObjects(ids, refs, 0, l1muonIds_.size()); }
0924     void getObjects(Vids& ids, VRl1muon& refs, size_type begin, size_type end) const {
0925       assert(begin <= end);
0926       assert(end <= l1muonIds_.size());
0927       const size_type n(end - begin);
0928       ids.resize(n);
0929       refs.resize(n);
0930       size_type j(0);
0931       for (size_type i = begin; i != end; ++i) {
0932         ids[j] = l1muonIds_[i];
0933         refs[j] = l1muonRefs_[i];
0934         ++j;
0935       }
0936     }
0937     void getObjects(int id, VRl1muon& refs) const { getObjects(id, refs, 0, l1muonIds_.size()); }
0938     void getObjects(int id, VRl1muon& refs, size_type begin, size_type end) const {
0939       assert(begin <= end);
0940       assert(end <= l1muonIds_.size());
0941       size_type n(0);
0942       for (size_type i = begin; i != end; ++i) {
0943         if (id == l1muonIds_[i]) {
0944           ++n;
0945         }
0946       }
0947       refs.resize(n);
0948       size_type j(0);
0949       for (size_type i = begin; i != end; ++i) {
0950         if (id == l1muonIds_[i]) {
0951           refs[j] = l1muonRefs_[i];
0952           ++j;
0953         }
0954       }
0955       return;
0956     }
0957 
0958     void getObjects(Vids& ids, VRl1jet& refs) const { getObjects(ids, refs, 0, l1jetIds_.size()); }
0959     void getObjects(Vids& ids, VRl1jet& refs, size_type begin, size_type end) const {
0960       assert(begin <= end);
0961       assert(end <= l1jetIds_.size());
0962       const size_type n(end - begin);
0963       ids.resize(n);
0964       refs.resize(n);
0965       size_type j(0);
0966       for (size_type i = begin; i != end; ++i) {
0967         ids[j] = l1jetIds_[i];
0968         refs[j] = l1jetRefs_[i];
0969         ++j;
0970       }
0971     }
0972     void getObjects(int id, VRl1jet& refs) const { getObjects(id, refs, 0, l1jetIds_.size()); }
0973     void getObjects(int id, VRl1jet& refs, size_type begin, size_type end) const {
0974       assert(begin <= end);
0975       assert(end <= l1jetIds_.size());
0976       size_type n(0);
0977       for (size_type i = begin; i != end; ++i) {
0978         if (id == l1jetIds_[i]) {
0979           ++n;
0980         }
0981       }
0982       refs.resize(n);
0983       size_type j(0);
0984       for (size_type i = begin; i != end; ++i) {
0985         if (id == l1jetIds_[i]) {
0986           refs[j] = l1jetRefs_[i];
0987           ++j;
0988         }
0989       }
0990       return;
0991     }
0992 
0993     void getObjects(Vids& ids, VRl1etmiss& refs) const { getObjects(ids, refs, 0, l1etmissIds_.size()); }
0994     void getObjects(Vids& ids, VRl1etmiss& refs, size_type begin, size_type end) const {
0995       assert(begin <= end);
0996       assert(end <= l1etmissIds_.size());
0997       const size_type n(end - begin);
0998       ids.resize(n);
0999       refs.resize(n);
1000       size_type j(0);
1001       for (size_type i = begin; i != end; ++i) {
1002         ids[j] = l1etmissIds_[i];
1003         refs[j] = l1etmissRefs_[i];
1004         ++j;
1005       }
1006     }
1007     void getObjects(int id, VRl1etmiss& refs) const { getObjects(id, refs, 0, l1etmissIds_.size()); }
1008     void getObjects(int id, VRl1etmiss& refs, size_type begin, size_type end) const {
1009       assert(begin <= end);
1010       assert(end <= l1etmissIds_.size());
1011       size_type n(0);
1012       for (size_type i = begin; i != end; ++i) {
1013         if (id == l1etmissIds_[i]) {
1014           ++n;
1015         }
1016       }
1017       refs.resize(n);
1018       size_type j(0);
1019       for (size_type i = begin; i != end; ++i) {
1020         if (id == l1etmissIds_[i]) {
1021           refs[j] = l1etmissRefs_[i];
1022           ++j;
1023         }
1024       }
1025       return;
1026     }
1027 
1028     void getObjects(Vids& ids, VRl1hfrings& refs) const { getObjects(ids, refs, 0, l1hfringsIds_.size()); }
1029     void getObjects(Vids& ids, VRl1hfrings& refs, size_type begin, size_type end) const {
1030       assert(begin <= end);
1031       assert(end <= l1hfringsIds_.size());
1032       const size_type n(end - begin);
1033       ids.resize(n);
1034       refs.resize(n);
1035       size_type j(0);
1036       for (size_type i = begin; i != end; ++i) {
1037         ids[j] = l1hfringsIds_[i];
1038         refs[j] = l1hfringsRefs_[i];
1039         ++j;
1040       }
1041     }
1042     void getObjects(int id, VRl1hfrings& refs) const { getObjects(id, refs, 0, l1hfringsIds_.size()); }
1043     void getObjects(int id, VRl1hfrings& refs, size_type begin, size_type end) const {
1044       assert(begin <= end);
1045       assert(end <= l1hfringsIds_.size());
1046       size_type n(0);
1047       for (size_type i = begin; i != end; ++i) {
1048         if (id == l1hfringsIds_[i]) {
1049           ++n;
1050         }
1051       }
1052       refs.resize(n);
1053       size_type j(0);
1054       for (size_type i = begin; i != end; ++i) {
1055         if (id == l1hfringsIds_[i]) {
1056           refs[j] = l1hfringsRefs_[i];
1057           ++j;
1058         }
1059       }
1060       return;
1061     }
1062 
1063     void getObjects(Vids& ids, VRl1tmuon& refs) const { getObjects(ids, refs, 0, l1tmuonIds_.size()); }
1064     void getObjects(Vids& ids, VRl1tmuon& refs, size_type begin, size_type end) const {
1065       assert(begin <= end);
1066       assert(end <= l1tmuonIds_.size());
1067       const size_type n(end - begin);
1068       ids.resize(n);
1069       refs.resize(n);
1070       size_type j(0);
1071       for (size_type i = begin; i != end; ++i) {
1072         ids[j] = l1tmuonIds_[i];
1073         refs[j] = l1tmuonRefs_[i];
1074         ++j;
1075       }
1076     }
1077     void getObjects(int id, VRl1tmuon& refs) const { getObjects(id, refs, 0, l1tmuonIds_.size()); }
1078     void getObjects(int id, VRl1tmuon& refs, size_type begin, size_type end) const {
1079       assert(begin <= end);
1080       assert(end <= l1tmuonIds_.size());
1081       size_type n(0);
1082       for (size_type i = begin; i != end; ++i) {
1083         if (id == l1tmuonIds_[i]) {
1084           ++n;
1085         }
1086       }
1087       refs.resize(n);
1088       size_type j(0);
1089       for (size_type i = begin; i != end; ++i) {
1090         if (id == l1tmuonIds_[i]) {
1091           refs[j] = l1tmuonRefs_[i];
1092           ++j;
1093         }
1094       }
1095       return;
1096     }
1097 
1098     void getObjects(Vids& ids, VRl1tmuonShower& refs) const { getObjects(ids, refs, 0, l1tmuonShowerIds_.size()); }
1099     void getObjects(Vids& ids, VRl1tmuonShower& refs, size_type begin, size_type end) const {
1100       assert(begin <= end);
1101       assert(end <= l1tmuonShowerIds_.size());
1102       const size_type n(end - begin);
1103       ids.resize(n);
1104       refs.resize(n);
1105       size_type j(0);
1106       for (size_type i = begin; i != end; ++i) {
1107         ids[j] = l1tmuonShowerIds_[i];
1108         refs[j] = l1tmuonShowerRefs_[i];
1109         ++j;
1110       }
1111     }
1112     void getObjects(int id, VRl1tmuonShower& refs) const { getObjects(id, refs, 0, l1tmuonShowerIds_.size()); }
1113     void getObjects(int id, VRl1tmuonShower& refs, size_type begin, size_type end) const {
1114       assert(begin <= end);
1115       assert(end <= l1tmuonShowerIds_.size());
1116       size_type n(0);
1117       for (size_type i = begin; i != end; ++i) {
1118         if (id == l1tmuonShowerIds_[i]) {
1119           ++n;
1120         }
1121       }
1122       refs.resize(n);
1123       size_type j(0);
1124       for (size_type i = begin; i != end; ++i) {
1125         if (id == l1tmuonShowerIds_[i]) {
1126           refs[j] = l1tmuonShowerRefs_[i];
1127           ++j;
1128         }
1129       }
1130       return;
1131     }
1132 
1133     void getObjects(Vids& ids, VRl1tegamma& refs) const { getObjects(ids, refs, 0, l1tegammaIds_.size()); }
1134     void getObjects(Vids& ids, VRl1tegamma& refs, size_type begin, size_type end) const {
1135       assert(begin <= end);
1136       assert(end <= l1tegammaIds_.size());
1137       const size_type n(end - begin);
1138       ids.resize(n);
1139       refs.resize(n);
1140       size_type j(0);
1141       for (size_type i = begin; i != end; ++i) {
1142         ids[j] = l1tegammaIds_[i];
1143         refs[j] = l1tegammaRefs_[i];
1144         ++j;
1145       }
1146     }
1147     void getObjects(int id, VRl1tegamma& refs) const { getObjects(id, refs, 0, l1tegammaIds_.size()); }
1148     void getObjects(int id, VRl1tegamma& refs, size_type begin, size_type end) const {
1149       assert(begin <= end);
1150       assert(end <= l1tegammaIds_.size());
1151       size_type n(0);
1152       for (size_type i = begin; i != end; ++i) {
1153         if (id == l1tegammaIds_[i]) {
1154           ++n;
1155         }
1156       }
1157       refs.resize(n);
1158       size_type j(0);
1159       for (size_type i = begin; i != end; ++i) {
1160         if (id == l1tegammaIds_[i]) {
1161           refs[j] = l1tegammaRefs_[i];
1162           ++j;
1163         }
1164       }
1165       return;
1166     }
1167 
1168     void getObjects(Vids& ids, VRl1tjet& refs) const { getObjects(ids, refs, 0, l1tjetIds_.size()); }
1169     void getObjects(Vids& ids, VRl1tjet& refs, size_type begin, size_type end) const {
1170       assert(begin <= end);
1171       assert(end <= l1tjetIds_.size());
1172       const size_type n(end - begin);
1173       ids.resize(n);
1174       refs.resize(n);
1175       size_type j(0);
1176       for (size_type i = begin; i != end; ++i) {
1177         ids[j] = l1tjetIds_[i];
1178         refs[j] = l1tjetRefs_[i];
1179         ++j;
1180       }
1181     }
1182     void getObjects(int id, VRl1tjet& refs) const { getObjects(id, refs, 0, l1tjetIds_.size()); }
1183     void getObjects(int id, VRl1tjet& refs, size_type begin, size_type end) const {
1184       assert(begin <= end);
1185       assert(end <= l1tjetIds_.size());
1186       size_type n(0);
1187       for (size_type i = begin; i != end; ++i) {
1188         if (id == l1tjetIds_[i]) {
1189           ++n;
1190         }
1191       }
1192       refs.resize(n);
1193       size_type j(0);
1194       for (size_type i = begin; i != end; ++i) {
1195         if (id == l1tjetIds_[i]) {
1196           refs[j] = l1tjetRefs_[i];
1197           ++j;
1198         }
1199       }
1200       return;
1201     }
1202 
1203     void getObjects(Vids& ids, VRl1ttau& refs) const { getObjects(ids, refs, 0, l1ttauIds_.size()); }
1204     void getObjects(Vids& ids, VRl1ttau& refs, size_type begin, size_type end) const {
1205       assert(begin <= end);
1206       assert(end <= l1ttauIds_.size());
1207       const size_type n(end - begin);
1208       ids.resize(n);
1209       refs.resize(n);
1210       size_type j(0);
1211       for (size_type i = begin; i != end; ++i) {
1212         ids[j] = l1ttauIds_[i];
1213         refs[j] = l1ttauRefs_[i];
1214         ++j;
1215       }
1216     }
1217     void getObjects(int id, VRl1ttau& refs) const { getObjects(id, refs, 0, l1ttauIds_.size()); }
1218     void getObjects(int id, VRl1ttau& refs, size_type begin, size_type end) const {
1219       assert(begin <= end);
1220       assert(end <= l1ttauIds_.size());
1221       size_type n(0);
1222       for (size_type i = begin; i != end; ++i) {
1223         if (id == l1ttauIds_[i]) {
1224           ++n;
1225         }
1226       }
1227       refs.resize(n);
1228       size_type j(0);
1229       for (size_type i = begin; i != end; ++i) {
1230         if (id == l1ttauIds_[i]) {
1231           refs[j] = l1ttauRefs_[i];
1232           ++j;
1233         }
1234       }
1235       return;
1236     }
1237 
1238     void getObjects(Vids& ids, VRl1tetsum& refs) const { getObjects(ids, refs, 0, l1tetsumIds_.size()); }
1239     void getObjects(Vids& ids, VRl1tetsum& refs, size_type begin, size_type end) const {
1240       assert(begin <= end);
1241       assert(end <= l1tetsumIds_.size());
1242       const size_type n(end - begin);
1243       ids.resize(n);
1244       refs.resize(n);
1245       size_type j(0);
1246       for (size_type i = begin; i != end; ++i) {
1247         ids[j] = l1tetsumIds_[i];
1248         refs[j] = l1tetsumRefs_[i];
1249         ++j;
1250       }
1251     }
1252     void getObjects(int id, VRl1tetsum& refs) const { getObjects(id, refs, 0, l1tetsumIds_.size()); }
1253     void getObjects(int id, VRl1tetsum& refs, size_type begin, size_type end) const {
1254       assert(begin <= end);
1255       assert(end <= l1tetsumIds_.size());
1256       size_type n(0);
1257       for (size_type i = begin; i != end; ++i) {
1258         if (id == l1tetsumIds_[i]) {
1259           ++n;
1260         }
1261       }
1262       refs.resize(n);
1263       size_type j(0);
1264       for (size_type i = begin; i != end; ++i) {
1265         if (id == l1tetsumIds_[i]) {
1266           refs[j] = l1tetsumRefs_[i];
1267           ++j;
1268         }
1269       }
1270       return;
1271     }
1272 
1273     /* Phase-2 */
1274     void getObjects(Vids& ids, VRl1ttkmuon& refs) const { getObjects(ids, refs, 0, l1ttkmuonIds_.size()); }
1275     void getObjects(Vids& ids, VRl1ttkmuon& refs, size_type begin, size_type end) const {
1276       assert(begin <= end);
1277       assert(end <= l1ttkmuonIds_.size());
1278       const size_type n(end - begin);
1279       ids.resize(n);
1280       refs.resize(n);
1281       size_type j(0);
1282       for (size_type i = begin; i != end; ++i) {
1283         ids[j] = l1ttkmuonIds_[i];
1284         refs[j] = l1ttkmuonRefs_[i];
1285         ++j;
1286       }
1287     }
1288     void getObjects(int id, VRl1ttkmuon& refs) const { getObjects(id, refs, 0, l1ttkmuonIds_.size()); }
1289     void getObjects(int id, VRl1ttkmuon& refs, size_type begin, size_type end) const {
1290       assert(begin <= end);
1291       assert(end <= l1ttkmuonIds_.size());
1292       size_type n(0);
1293       for (size_type i = begin; i != end; ++i) {
1294         if (id == l1ttkmuonIds_[i]) {
1295           ++n;
1296         }
1297       }
1298       refs.resize(n);
1299       size_type j(0);
1300       for (size_type i = begin; i != end; ++i) {
1301         if (id == l1ttkmuonIds_[i]) {
1302           refs[j] = l1ttkmuonRefs_[i];
1303           ++j;
1304         }
1305       }
1306       return;
1307     }
1308 
1309     void getObjects(Vids& ids, VRl1ttkele& refs) const { getObjects(ids, refs, 0, l1ttkeleIds_.size()); }
1310     void getObjects(Vids& ids, VRl1ttkele& refs, size_type begin, size_type end) const {
1311       assert(begin <= end);
1312       assert(end <= l1ttkeleIds_.size());
1313       const size_type n(end - begin);
1314       ids.resize(n);
1315       refs.resize(n);
1316       size_type j(0);
1317       for (size_type i = begin; i != end; ++i) {
1318         ids[j] = l1ttkeleIds_[i];
1319         refs[j] = l1ttkeleRefs_[i];
1320         ++j;
1321       }
1322     }
1323     void getObjects(int id, VRl1ttkele& refs) const { getObjects(id, refs, 0, l1ttkeleIds_.size()); }
1324     void getObjects(int id, VRl1ttkele& refs, size_type begin, size_type end) const {
1325       assert(begin <= end);
1326       assert(end <= l1ttkeleIds_.size());
1327       size_type n(0);
1328       for (size_type i = begin; i != end; ++i) {
1329         if (id == l1ttkeleIds_[i]) {
1330           ++n;
1331         }
1332       }
1333       refs.resize(n);
1334       size_type j(0);
1335       for (size_type i = begin; i != end; ++i) {
1336         if (id == l1ttkeleIds_[i]) {
1337           refs[j] = l1ttkeleRefs_[i];
1338           ++j;
1339         }
1340       }
1341       return;
1342     }
1343 
1344     void getObjects(Vids& ids, VRl1ttkem& refs) const { getObjects(ids, refs, 0, l1ttkemIds_.size()); }
1345     void getObjects(Vids& ids, VRl1ttkem& refs, size_type begin, size_type end) const {
1346       assert(begin <= end);
1347       assert(end <= l1ttkemIds_.size());
1348       const size_type n(end - begin);
1349       ids.resize(n);
1350       refs.resize(n);
1351       size_type j(0);
1352       for (size_type i = begin; i != end; ++i) {
1353         ids[j] = l1ttkemIds_[i];
1354         refs[j] = l1ttkemRefs_[i];
1355         ++j;
1356       }
1357     }
1358     void getObjects(int id, VRl1ttkem& refs) const { getObjects(id, refs, 0, l1ttkemIds_.size()); }
1359     void getObjects(int id, VRl1ttkem& refs, size_type begin, size_type end) const {
1360       assert(begin <= end);
1361       assert(end <= l1ttkemIds_.size());
1362       size_type n(0);
1363       for (size_type i = begin; i != end; ++i) {
1364         if (id == l1ttkemIds_[i]) {
1365           ++n;
1366         }
1367       }
1368       refs.resize(n);
1369       size_type j(0);
1370       for (size_type i = begin; i != end; ++i) {
1371         if (id == l1ttkemIds_[i]) {
1372           refs[j] = l1ttkemRefs_[i];
1373           ++j;
1374         }
1375       }
1376       return;
1377     }
1378 
1379     void getObjects(Vids& ids, VRl1tpfjet& refs) const { getObjects(ids, refs, 0, l1tpfjetIds_.size()); }
1380     void getObjects(Vids& ids, VRl1tpfjet& refs, size_type begin, size_type end) const {
1381       assert(begin <= end);
1382       assert(end <= l1tpfjetIds_.size());
1383       const size_type n(end - begin);
1384       ids.resize(n);
1385       refs.resize(n);
1386       size_type j(0);
1387       for (size_type i = begin; i != end; ++i) {
1388         ids[j] = l1tpfjetIds_[i];
1389         refs[j] = l1tpfjetRefs_[i];
1390         ++j;
1391       }
1392     }
1393     void getObjects(int id, VRl1tpfjet& refs) const { getObjects(id, refs, 0, l1tpfjetIds_.size()); }
1394     void getObjects(int id, VRl1tpfjet& refs, size_type begin, size_type end) const {
1395       assert(begin <= end);
1396       assert(end <= l1tpfjetIds_.size());
1397       size_type n(0);
1398       for (size_type i = begin; i != end; ++i) {
1399         if (id == l1tpfjetIds_[i]) {
1400           ++n;
1401         }
1402       }
1403       refs.resize(n);
1404       size_type j(0);
1405       for (size_type i = begin; i != end; ++i) {
1406         if (id == l1tpfjetIds_[i]) {
1407           refs[j] = l1tpfjetRefs_[i];
1408           ++j;
1409         }
1410       }
1411       return;
1412     }
1413 
1414     void getObjects(Vids& ids, VRl1tpftau& refs) const { getObjects(ids, refs, 0, l1tpftauIds_.size()); }
1415     void getObjects(Vids& ids, VRl1tpftau& refs, size_type begin, size_type end) const {
1416       assert(begin <= end);
1417       assert(end <= l1tpftauIds_.size());
1418       const size_type n(end - begin);
1419       ids.resize(n);
1420       refs.resize(n);
1421       size_type j(0);
1422       for (size_type i = begin; i != end; ++i) {
1423         ids[j] = l1tpftauIds_[i];
1424         refs[j] = l1tpftauRefs_[i];
1425         ++j;
1426       }
1427     }
1428     void getObjects(int id, VRl1tpftau& refs) const { getObjects(id, refs, 0, l1tpftauIds_.size()); }
1429     void getObjects(int id, VRl1tpftau& refs, size_type begin, size_type end) const {
1430       assert(begin <= end);
1431       assert(end <= l1tpftauIds_.size());
1432       size_type n(0);
1433       for (size_type i = begin; i != end; ++i) {
1434         if (id == l1tpftauIds_[i]) {
1435           ++n;
1436         }
1437       }
1438       refs.resize(n);
1439       size_type j(0);
1440       for (size_type i = begin; i != end; ++i) {
1441         if (id == l1tpftauIds_[i]) {
1442           refs[j] = l1tpftauRefs_[i];
1443           ++j;
1444         }
1445       }
1446       return;
1447     }
1448 
1449     void getObjects(Vids& ids, VRl1thpspftau& refs) const { getObjects(ids, refs, 0, l1thpspftauIds_.size()); }
1450     void getObjects(Vids& ids, VRl1thpspftau& refs, size_type begin, size_type end) const {
1451       assert(begin <= end);
1452       assert(end <= l1thpspftauIds_.size());
1453       const size_type n(end - begin);
1454       ids.resize(n);
1455       refs.resize(n);
1456       size_type j(0);
1457       for (size_type i = begin; i != end; ++i) {
1458         ids[j] = l1thpspftauIds_[i];
1459         refs[j] = l1thpspftauRefs_[i];
1460         ++j;
1461       }
1462     }
1463     void getObjects(int id, VRl1thpspftau& refs) const { getObjects(id, refs, 0, l1thpspftauIds_.size()); }
1464     void getObjects(int id, VRl1thpspftau& refs, size_type begin, size_type end) const {
1465       assert(begin <= end);
1466       assert(end <= l1thpspftauIds_.size());
1467       size_type n(0);
1468       for (size_type i = begin; i != end; ++i) {
1469         if (id == l1thpspftauIds_[i]) {
1470           ++n;
1471         }
1472       }
1473       refs.resize(n);
1474       size_type j(0);
1475       for (size_type i = begin; i != end; ++i) {
1476         if (id == l1thpspftauIds_[i]) {
1477           refs[j] = l1thpspftauRefs_[i];
1478           ++j;
1479         }
1480       }
1481       return;
1482     }
1483 
1484     void getObjects(Vids& ids, VRl1tpftrack& refs) const { getObjects(ids, refs, 0, l1tpftrackIds_.size()); }
1485     void getObjects(Vids& ids, VRl1tpftrack& refs, size_type begin, size_type end) const {
1486       assert(begin <= end);
1487       assert(end <= l1tpftrackIds_.size());
1488       const size_type n(end - begin);
1489       ids.resize(n);
1490       refs.resize(n);
1491       size_type j(0);
1492       for (size_type i = begin; i != end; ++i) {
1493         ids[j] = l1tpftrackIds_[i];
1494         refs[j] = l1tpftrackRefs_[i];
1495         ++j;
1496       }
1497     }
1498     void getObjects(int id, VRl1tpftrack& refs) const { getObjects(id, refs, 0, l1tpftrackIds_.size()); }
1499     void getObjects(int id, VRl1tpftrack& refs, size_type begin, size_type end) const {
1500       assert(begin <= end);
1501       assert(end <= l1tpftrackIds_.size());
1502       size_type n(0);
1503       for (size_type i = begin; i != end; ++i) {
1504         if (id == l1tpftrackIds_[i]) {
1505           ++n;
1506         }
1507       }
1508       refs.resize(n);
1509       size_type j(0);
1510       for (size_type i = begin; i != end; ++i) {
1511         if (id == l1tpftrackIds_[i]) {
1512           refs[j] = l1tpftrackRefs_[i];
1513           ++j;
1514         }
1515       }
1516       return;
1517     }
1518 
1519     void getObjects(Vids& ids, VRpfjet& refs) const { getObjects(ids, refs, 0, pfjetIds_.size()); }
1520     void getObjects(Vids& ids, VRpfjet& refs, size_type begin, size_type end) const {
1521       assert(begin <= end);
1522       assert(end <= pfjetIds_.size());
1523       const size_type n(end - begin);
1524       ids.resize(n);
1525       refs.resize(n);
1526       size_type j(0);
1527       for (size_type i = begin; i != end; ++i) {
1528         ids[j] = pfjetIds_[i];
1529         refs[j] = pfjetRefs_[i];
1530         ++j;
1531       }
1532     }
1533     void getObjects(int id, VRpfjet& refs) const { getObjects(id, refs, 0, pfjetIds_.size()); }
1534     void getObjects(int id, VRpfjet& refs, size_type begin, size_type end) const {
1535       assert(begin <= end);
1536       assert(end <= pfjetIds_.size());
1537       size_type n(0);
1538       for (size_type i = begin; i != end; ++i) {
1539         if (id == pfjetIds_[i]) {
1540           ++n;
1541         }
1542       }
1543       refs.resize(n);
1544       size_type j(0);
1545       for (size_type i = begin; i != end; ++i) {
1546         if (id == pfjetIds_[i]) {
1547           refs[j] = pfjetRefs_[i];
1548           ++j;
1549         }
1550       }
1551       return;
1552     }
1553 
1554     void getObjects(Vids& ids, VRpftau& refs) const { getObjects(ids, refs, 0, pftauIds_.size()); }
1555     void getObjects(Vids& ids, VRpftau& refs, size_type begin, size_type end) const {
1556       assert(begin <= end);
1557       assert(end <= pftauIds_.size());
1558       const size_type n(end - begin);
1559       ids.resize(n);
1560       refs.resize(n);
1561       size_type j(0);
1562       for (size_type i = begin; i != end; ++i) {
1563         ids[j] = pftauIds_[i];
1564         refs[j] = pftauRefs_[i];
1565         ++j;
1566       }
1567     }
1568     void getObjects(int id, VRpftau& refs) const { getObjects(id, refs, 0, pftauIds_.size()); }
1569     void getObjects(int id, VRpftau& refs, size_type begin, size_type end) const {
1570       assert(begin <= end);
1571       assert(end <= pftauIds_.size());
1572       size_type n(0);
1573       for (size_type i = begin; i != end; ++i) {
1574         if (id == pftauIds_[i]) {
1575           ++n;
1576         }
1577       }
1578       refs.resize(n);
1579       size_type j(0);
1580       for (size_type i = begin; i != end; ++i) {
1581         if (id == pftauIds_[i]) {
1582           refs[j] = pftauRefs_[i];
1583           ++j;
1584         }
1585       }
1586       return;
1587     }
1588 
1589     void getObjects(Vids& ids, VRpfmet& refs) const { getObjects(ids, refs, 0, pfmetIds_.size()); }
1590     void getObjects(Vids& ids, VRpfmet& refs, size_type begin, size_type end) const {
1591       assert(begin <= end);
1592       assert(end <= pfmetIds_.size());
1593       const size_type n(end - begin);
1594       ids.resize(n);
1595       refs.resize(n);
1596       size_type j(0);
1597       for (size_type i = begin; i != end; ++i) {
1598         ids[j] = pfmetIds_[i];
1599         refs[j] = pfmetRefs_[i];
1600         ++j;
1601       }
1602     }
1603     void getObjects(int id, VRpfmet& refs) const { getObjects(id, refs, 0, pfmetIds_.size()); }
1604     void getObjects(int id, VRpfmet& refs, size_type begin, size_type end) const {
1605       assert(begin <= end);
1606       assert(end <= pfmetIds_.size());
1607       size_type n(0);
1608       for (size_type i = begin; i != end; ++i) {
1609         if (id == pfmetIds_[i]) {
1610           ++n;
1611         }
1612       }
1613       refs.resize(n);
1614       size_type j(0);
1615       for (size_type i = begin; i != end; ++i) {
1616         if (id == pfmetIds_[i]) {
1617           refs[j] = pfmetRefs_[i];
1618           ++j;
1619         }
1620       }
1621       return;
1622     }
1623 
1624     /// low-level getters for data members
1625     size_type photonSize() const { return photonIds_.size(); }
1626     const Vids& photonIds() const { return photonIds_; }
1627     const VRphoton& photonRefs() const { return photonRefs_; }
1628 
1629     size_type electronSize() const { return electronIds_.size(); }
1630     const Vids& electronIds() const { return electronIds_; }
1631     const VRelectron& electronRefs() const { return electronRefs_; }
1632 
1633     size_type muonSize() const { return muonIds_.size(); }
1634     const Vids& muonIds() const { return muonIds_; }
1635     const VRmuon& muonRefs() const { return muonRefs_; }
1636 
1637     size_type jetSize() const { return jetIds_.size(); }
1638     const Vids& jetIds() const { return jetIds_; }
1639     const VRjet& jetRefs() const { return jetRefs_; }
1640 
1641     size_type compositeSize() const { return compositeIds_.size(); }
1642     const Vids& compositeIds() const { return compositeIds_; }
1643     const VRcomposite& compositeRefs() const { return compositeRefs_; }
1644 
1645     size_type basemetSize() const { return basemetIds_.size(); }
1646     const Vids& basemetIds() const { return basemetIds_; }
1647     const VRbasemet& basemetRefs() const { return basemetRefs_; }
1648 
1649     size_type calometSize() const { return calometIds_.size(); }
1650     const Vids& calometIds() const { return calometIds_; }
1651     const VRcalomet& calometRefs() const { return calometRefs_; }
1652 
1653     size_type pixtrackSize() const { return pixtrackIds_.size(); }
1654     const Vids& pixtrackIds() const { return pixtrackIds_; }
1655     const VRpixtrack& pixtrackRefs() const { return pixtrackRefs_; }
1656 
1657     size_type l1emSize() const { return l1emIds_.size(); }
1658     const Vids& l1emIds() const { return l1emIds_; }
1659     const VRl1em& l1emRefs() const { return l1emRefs_; }
1660 
1661     size_type l1muonSize() const { return l1muonIds_.size(); }
1662     const Vids& l1muonIds() const { return l1muonIds_; }
1663     const VRl1muon& l1muonRefs() const { return l1muonRefs_; }
1664 
1665     size_type l1jetSize() const { return l1jetIds_.size(); }
1666     const Vids& l1jetIds() const { return l1jetIds_; }
1667     const VRl1jet& l1jetRefs() const { return l1jetRefs_; }
1668 
1669     size_type l1etmissSize() const { return l1etmissIds_.size(); }
1670     const Vids& l1etmissIds() const { return l1etmissIds_; }
1671     const VRl1etmiss& l1etmissRefs() const { return l1etmissRefs_; }
1672 
1673     size_type l1hfringsSize() const { return l1hfringsIds_.size(); }
1674     const Vids& l1hfringsIds() const { return l1hfringsIds_; }
1675     const VRl1hfrings& l1hfringsRefs() const { return l1hfringsRefs_; }
1676 
1677     size_type pfjetSize() const { return pfjetIds_.size(); }
1678     const Vids& pfjetIds() const { return pfjetIds_; }
1679     const VRpfjet& pfjetRefs() const { return pfjetRefs_; }
1680 
1681     size_type pftauSize() const { return pftauIds_.size(); }
1682     const Vids& pftauIds() const { return pftauIds_; }
1683     const VRpftau& pftauRefs() const { return pftauRefs_; }
1684 
1685     size_type pfmetSize() const { return pfmetIds_.size(); }
1686     const Vids& pfmetIds() const { return pfmetIds_; }
1687     const VRpfmet& pfmetRefs() const { return pfmetRefs_; }
1688 
1689     size_type l1tmuonSize() const { return l1tmuonIds_.size(); }
1690     const Vids& l1tmuonIds() const { return l1tmuonIds_; }
1691     const VRl1tmuon& l1tmuonRefs() const { return l1tmuonRefs_; }
1692 
1693     size_type l1tmuonShowerSize() const { return l1tmuonShowerIds_.size(); }
1694     const Vids& l1tmuonShowerIds() const { return l1tmuonShowerIds_; }
1695     const VRl1tmuonShower& l1tmuonShowerRefs() const { return l1tmuonShowerRefs_; }
1696 
1697     size_type l1tegammaSize() const { return l1tegammaIds_.size(); }
1698     const Vids& l1tegammaIds() const { return l1tegammaIds_; }
1699     const VRl1tegamma& l1tegammaRefs() const { return l1tegammaRefs_; }
1700 
1701     size_type l1tjetSize() const { return l1tjetIds_.size(); }
1702     const Vids& l1tjetIds() const { return l1tjetIds_; }
1703     const VRl1tjet& l1tjetRefs() const { return l1tjetRefs_; }
1704 
1705     /* Phase-2 */
1706 
1707     size_type l1ttkmuonSize() const { return l1ttkmuonIds_.size(); }
1708     const Vids& l1ttkmuonIds() const { return l1ttkmuonIds_; }
1709     const VRl1ttkmuon& l1ttkmuonRefs() const { return l1ttkmuonRefs_; }
1710 
1711     size_type l1ttkeleSize() const { return l1ttkeleIds_.size(); }
1712     const Vids& l1ttkeleIds() const { return l1ttkeleIds_; }
1713     const VRl1ttkele& l1ttkeleRefs() const { return l1ttkeleRefs_; }
1714 
1715     size_type l1ttkemSize() const { return l1ttkemIds_.size(); }
1716     const Vids& l1ttkemIds() const { return l1ttkemIds_; }
1717     const VRl1ttkem& l1ttkemRefs() const { return l1ttkemRefs_; }
1718 
1719     size_type l1tpfjetSize() const { return l1tpfjetIds_.size(); }
1720     const Vids& l1tpfjetIds() const { return l1tpfjetIds_; }
1721     const VRl1tpfjet& l1tpfjetRefs() const { return l1tpfjetRefs_; }
1722 
1723     size_type l1tpftauSize() const { return l1tpftauIds_.size(); }
1724     const Vids& l1tpftauIds() const { return l1tpftauIds_; }
1725     const VRl1tpftau& l1tpftauRefs() const { return l1tpftauRefs_; }
1726 
1727     size_type l1thpspftauSize() const { return l1thpspftauIds_.size(); }
1728     const Vids& l1thpspftauIds() const { return l1thpspftauIds_; }
1729     const VRl1thpspftau& l1thpspftauRefs() const { return l1thpspftauRefs_; }
1730 
1731     size_type l1tpftrackSize() const { return l1tpftrackIds_.size(); }
1732     const Vids& l1tpftrackIds() const { return l1tpftrackIds_; }
1733     const VRl1tpftrack& l1tpftrackRefs() const { return l1tpftrackRefs_; }
1734 
1735     size_type l1ttauSize() const { return l1ttauIds_.size(); }
1736     const Vids& l1ttauIds() const { return l1ttauIds_; }
1737     const VRl1ttau& l1ttauRefs() const { return l1ttauRefs_; }
1738 
1739     size_type l1tetsumSize() const { return l1tetsumIds_.size(); }
1740     const Vids& l1tetsumIds() const { return l1tetsumIds_; }
1741     const VRl1tetsum& l1tetsumRefs() const { return l1tetsumRefs_; }
1742   };
1743 
1744   // picked up via argument dependent lookup, e-g- by boost::swap()
1745   inline void swap(TriggerRefsCollections& first, TriggerRefsCollections& second) { first.swap(second); }
1746 
1747 }  // namespace trigger
1748 
1749 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!