TriggerSummaryProducerAOD.cc

Go to the documentation of this file.

#include <algorithm>
#include <memory>
#include <typeinfo>

#include "HLTrigger/HLTcore/interface/TriggerSummaryProducerAOD.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"

#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/HLTReco/interface/TriggerEvent.h"
#include "DataFormats/Provenance/interface/Provenance.h"
#include "FWCore/Framework/interface/ProcessMatch.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "DataFormats/RecoCandidate/interface/RecoEcalCandidate.h"
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
#include "DataFormats/JetReco/interface/CaloJet.h"
#include "DataFormats/Candidate/interface/CompositeCandidate.h"
#include "DataFormats/METReco/interface/MET.h"
#include "DataFormats/METReco/interface/METFwd.h"
#include "DataFormats/METReco/interface/CaloMET.h"
#include "DataFormats/METReco/interface/CaloMETFwd.h"
#include "DataFormats/METReco/interface/PFMET.h"
#include "DataFormats/METReco/interface/PFMETFwd.h"
#include "DataFormats/HcalIsolatedTrack/interface/IsolatedPixelTrackCandidate.h"

#include "DataFormats/L1Trigger/interface/L1HFRings.h"
#include "DataFormats/L1Trigger/interface/L1EmParticle.h"
#include "DataFormats/L1Trigger/interface/L1JetParticle.h"
#include "DataFormats/L1Trigger/interface/L1MuonParticle.h"
#include "DataFormats/L1Trigger/interface/L1EtMissParticle.h"

#include "DataFormats/L1Trigger/interface/Muon.h"
#include "DataFormats/L1Trigger/interface/EGamma.h"
#include "DataFormats/L1Trigger/interface/Jet.h"
#include "DataFormats/L1Trigger/interface/Tau.h"
#include "DataFormats/L1Trigger/interface/EtSum.h"

#include "DataFormats/JetReco/interface/PFJet.h"
#include "DataFormats/TauReco/interface/PFTau.h"

#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Framework/interface/TriggerNamesService.h"

#include "boost/algorithm/string.hpp"

namespace {
  std::vector<std::regex> convertToRegex(std::vector<std::string> const& iPatterns) {
    std::vector<std::regex> result;

    for(auto const& pattern: iPatterns) {
      auto regexPattern = pattern;
      boost::replace_all(regexPattern, "*", ".*");
      boost::replace_all(regexPattern, "?", ".");

      result.emplace_back(regexPattern);
    }
    return result;
  }
}

//
// constructors and destructor
//
TriggerSummaryProducerAOD::TriggerSummaryProducerAOD(const edm::ParameterSet& ps, const GlobalInputTags * gt) : 
  pn_(ps.getParameter<std::string>("processName")),
  moduleLabelPatternsToMatch_(convertToRegex(ps.getParameter<std::vector<std::string>>("moduleLabelPatternsToMatch"))),
  moduleLabelPatternsToSkip_(convertToRegex(ps.getParameter<std::vector<std::string>>("moduleLabelPatternsToSkip"))),
  filterTagsEvent_(pn_!="*"),
  filterTagsStream_(pn_!="*"),
  collectionTagsEvent_(pn_!="*"),
  collectionTagsStream_(pn_!="*"),
  toc_(),
  tags_(),
  offset_(),
  keys_(),
  ids_(),
  maskFilters_()
{
  if (pn_=="@") {
    edm::Service<edm::service::TriggerNamesService> tns;
    if (tns.isAvailable()) {
      pn_ = tns->getProcessName();
    } else {
      edm::LogError("TriggerSummaryProducerAOD") << "HLT Error: TriggerNamesService not available!";
      pn_="*";
    }

    filterTagsEvent_     =InputTagSet(pn_!="*");
    filterTagsStream_    =InputTagSet(pn_!="*");
    collectionTagsEvent_ =InputTagSet(pn_!="*");
    collectionTagsStream_=InputTagSet(pn_!="*");
  }
  LogDebug("TriggerSummaryProducerAOD") << "Using process name: '" << pn_ <<"'";

  filterTagsStream_.clear();
  collectionTagsStream_.clear();

  produces<trigger::TriggerEvent>();

  auto const* pProcessName = &pn_;
  auto const& moduleLabelPatternsToMatch = moduleLabelPatternsToMatch_;
  auto const& moduleLabelPatternsToSkip = moduleLabelPatternsToSkip_;
  auto productMatch = [pProcessName,&moduleLabelPatternsToSkip,&moduleLabelPatternsToMatch](edm::BranchDescription const& iBranch) -> bool {
    if(iBranch.processName() == *pProcessName || *pProcessName == "*") {
      auto const& label = iBranch.moduleLabel();
      for(auto& match: moduleLabelPatternsToMatch) {
        if(std::regex_match(label,match)) {
          //make sure this is not in the reject list
          for(auto& reject: moduleLabelPatternsToSkip) {
            if(std::regex_match(label,reject)) {
              return false;
            }
          }
          return true;
        }
      }
    }
    return false;
  };

  getTriggerFilterObjectWithRefs_ = edm::GetterOfProducts<trigger::TriggerFilterObjectWithRefs>(productMatch, this);
  getRecoEcalCandidateCollection_ = edm::GetterOfProducts<reco::RecoEcalCandidateCollection>(productMatch, this);
  getElectronCollection_ = edm::GetterOfProducts<reco::ElectronCollection>(productMatch, this);
  getRecoChargedCandidateCollection_ = edm::GetterOfProducts<reco::RecoChargedCandidateCollection>(productMatch, this);
  getCaloJetCollection_ = edm::GetterOfProducts<reco::CaloJetCollection>(productMatch, this);
  getCompositeCandidateCollection_ = edm::GetterOfProducts<reco::CompositeCandidateCollection>(productMatch, this);
  getMETCollection_ = edm::GetterOfProducts<reco::METCollection>(productMatch, this);
  getCaloMETCollection_ = edm::GetterOfProducts<reco::CaloMETCollection>(productMatch, this);
  getIsolatedPixelTrackCandidateCollection_ = edm::GetterOfProducts<reco::IsolatedPixelTrackCandidateCollection>(productMatch, this);
  getL1EmParticleCollection_ = edm::GetterOfProducts<l1extra::L1EmParticleCollection>(productMatch, this);
  getL1MuonParticleCollection_ = edm::GetterOfProducts<l1extra::L1MuonParticleCollection>(productMatch, this);
  getL1JetParticleCollection_ = edm::GetterOfProducts<l1extra::L1JetParticleCollection>(productMatch, this);
  getL1EtMissParticleCollection_ = edm::GetterOfProducts<l1extra::L1EtMissParticleCollection>(productMatch, this);
  getL1HFRingsCollection_ = edm::GetterOfProducts<l1extra::L1HFRingsCollection>(productMatch, this);
  getL1TMuonParticleCollection_ = edm::GetterOfProducts<l1t::MuonBxCollection>(productMatch, this);
  getL1TEGammaParticleCollection_ = edm::GetterOfProducts<l1t::EGammaBxCollection>(productMatch, this);
  getL1TJetParticleCollection_ = edm::GetterOfProducts<l1t::JetBxCollection>(productMatch, this);
  getL1TTauParticleCollection_ = edm::GetterOfProducts<l1t::TauBxCollection>(productMatch, this);
  getL1TEtSumParticleCollection_ = edm::GetterOfProducts<l1t::EtSumBxCollection>(productMatch, this);
  getPFJetCollection_ = edm::GetterOfProducts<reco::PFJetCollection>(productMatch, this);
  getPFTauCollection_ = edm::GetterOfProducts<reco::PFTauCollection>(productMatch, this);
  getPFMETCollection_ = edm::GetterOfProducts<reco::PFMETCollection>(productMatch, this);

  callWhenNewProductsRegistered([this](edm::BranchDescription const& bd){
    getTriggerFilterObjectWithRefs_(bd);
    getRecoEcalCandidateCollection_(bd);
    getElectronCollection_(bd);
    getRecoChargedCandidateCollection_(bd);
    getCaloJetCollection_(bd);
    getCompositeCandidateCollection_(bd);
    getMETCollection_(bd);
    getCaloMETCollection_(bd);
    getIsolatedPixelTrackCandidateCollection_(bd);
    getL1EmParticleCollection_(bd);
    getL1MuonParticleCollection_(bd);
    getL1JetParticleCollection_(bd);
    getL1EtMissParticleCollection_(bd);
    getL1HFRingsCollection_(bd);
    getL1TMuonParticleCollection_(bd);
    getL1TEGammaParticleCollection_(bd);
    getL1TJetParticleCollection_(bd);
    getL1TTauParticleCollection_(bd);
    getL1TEtSumParticleCollection_(bd);
    getPFJetCollection_(bd);
    getPFTauCollection_(bd);
    getPFMETCollection_(bd);
  });
}

TriggerSummaryProducerAOD::~TriggerSummaryProducerAOD() = default;

//
// member functions
//

namespace {
  inline void
  tokenizeTag(const std::string& tag, std::string& label, std::string& instance, std::string& process){
    
    using std::string;
    
    const char token(':');
    const string empty;
    
    label=tag;
    const string::size_type i1(label.find(token));
    if (i1==string::npos) {
      instance=empty;
      process=empty;
    } else {
      instance=label.substr(i1+1);
      label.resize(i1);
      const string::size_type i2(instance.find(token));
      if (i2==string::npos) {
    process=empty;
      } else {
    process=instance.substr(i2+1);
    instance.resize(i2);
      }
    }
  }
}

void TriggerSummaryProducerAOD::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<std::string>("processName","@")->setComment("Process name to use when getting data. The value of '@' is used to denote the current process name.");
  desc.add<std::vector<std::string>>("moduleLabelPatternsToMatch",std::vector<std::string>(1,"hlt*"))->setComment("glob patterns for module labels to get data.");
  desc.add<std::vector<std::string>>("moduleLabelPatternsToSkip",std::vector<std::string>())->setComment("module labels for data products which should not be gotten.");
  descriptions.add("triggerSummaryProducerAOD", desc);
}

// ------------ method called to produce the data  ------------
void
TriggerSummaryProducerAOD::produce(edm::Event& iEvent, const edm::EventSetup& iSetup)
{
   using namespace std;
   using namespace edm;
   using namespace reco;
   using namespace l1extra;
   using namespace trigger;
   using namespace l1t;

   std::vector<edm::Handle<trigger::TriggerFilterObjectWithRefs> > fobs;
   getTriggerFilterObjectWithRefs_.fillHandles(iEvent, fobs);

   const unsigned int nfob(fobs.size());
   LogTrace("TriggerSummaryProducerAOD") << "Number of filter  objects found: " << nfob;

   string tagLabel,tagInstance,tagProcess;

   maskFilters_.clear();
   maskFilters_.resize(nfob);
   filterTagsEvent_.clear();
   collectionTagsEvent_.clear();
   unsigned int nf(0);
   for (unsigned int ifob=0; ifob!=nfob; ++ifob) {
     maskFilters_[ifob]=false;
     const vector<string>& collectionTags_(fobs[ifob]->getCollectionTagsAsStrings());
     const unsigned int ncol(collectionTags_.size());
     if (ncol>0) {
       nf++;
       maskFilters_[ifob]=true;
       const string& label    (fobs[ifob].provenance()->moduleLabel());
       const string& instance (fobs[ifob].provenance()->productInstanceName());
       const string& process  (fobs[ifob].provenance()->processName());
       filterTagsEvent_.insert(InputTag(label,instance,process));
       for (unsigned int icol=0; icol!=ncol; ++icol) {
     // overwrite process name (usually not set)
     tokenizeTag(collectionTags_[icol],tagLabel,tagInstance,tagProcess);
     collectionTagsEvent_.insert(InputTag(tagLabel,tagInstance,pn_));
       }
     }
   }
   if (filterTagsEvent_.size()!=nf) {
     LogError("TriggerSummaryProducerAOD")
       << "Mismatch in number of filter tags: "
       << filterTagsEvent_.size() << "!=" << nf ;
   }

   collectionTagsStream_.insert(collectionTagsEvent_.begin(),collectionTagsEvent_.end());
   filterTagsStream_.insert(filterTagsEvent_.begin(),filterTagsEvent_.end());

   if (isDebugEnabled()) {

     const unsigned int nc(collectionTagsEvent_.size());
     LogTrace("TriggerSummaryProducerAOD") << "Number of unique collections requested " << nc;
     const InputTagSet::const_iterator cb(collectionTagsEvent_.begin());
     const InputTagSet::const_iterator ce(collectionTagsEvent_.end());
     for ( InputTagSet::const_iterator ci=cb; ci!=ce; ++ci) {
       LogTrace("TriggerSummaryProducerAOD") << distance(cb,ci) << " " << ci->encode();
     }
     const unsigned int nf(filterTagsEvent_.size());
     LogTrace("TriggerSummaryProducerAOD") << "Number of unique filters requested " << nf;
     const InputTagSet::const_iterator fb(filterTagsEvent_.begin());
     const InputTagSet::const_iterator fe(filterTagsEvent_.end());
     for ( InputTagSet::const_iterator fi=fb; fi!=fe; ++fi) {
       LogTrace("TriggerSummaryProducerAOD") << distance(fb,fi) << " " << fi->encode();
     }

   }

   toc_.clear();
   tags_.clear();
   keys_.clear();
   offset_.clear();
   fillTriggerObjectCollections<          RecoEcalCandidateCollection>(iEvent, getRecoEcalCandidateCollection_);
   fillTriggerObjectCollections<                   ElectronCollection>(iEvent, getElectronCollection_);
   fillTriggerObjectCollections<       RecoChargedCandidateCollection>(iEvent, getRecoChargedCandidateCollection_);
   fillTriggerObjectCollections<                    CaloJetCollection>(iEvent, getCaloJetCollection_);
   fillTriggerObjectCollections<         CompositeCandidateCollection>(iEvent, getCompositeCandidateCollection_);
   fillTriggerObjectCollections<                        METCollection>(iEvent, getMETCollection_);
   fillTriggerObjectCollections<                    CaloMETCollection>(iEvent, getCaloMETCollection_);
   fillTriggerObjectCollections<IsolatedPixelTrackCandidateCollection>(iEvent, getIsolatedPixelTrackCandidateCollection_);
   fillTriggerObjectCollections<               L1EmParticleCollection>(iEvent, getL1EmParticleCollection_);
   fillTriggerObjectCollections<             L1MuonParticleCollection>(iEvent, getL1MuonParticleCollection_);
   fillTriggerObjectCollections<              L1JetParticleCollection>(iEvent, getL1JetParticleCollection_);
   fillTriggerObjectCollections<           L1EtMissParticleCollection>(iEvent, getL1EtMissParticleCollection_);
   fillTriggerObjectCollections<                  L1HFRingsCollection>(iEvent, getL1HFRingsCollection_);
   fillTriggerObjectCollections<                     MuonBxCollection>(iEvent, getL1TMuonParticleCollection_);
   fillTriggerObjectCollections<                   EGammaBxCollection>(iEvent, getL1TEGammaParticleCollection_);
   fillTriggerObjectCollections<                      JetBxCollection>(iEvent, getL1TJetParticleCollection_);
   fillTriggerObjectCollections<                      TauBxCollection>(iEvent, getL1TTauParticleCollection_);
   fillTriggerObjectCollections<                    EtSumBxCollection>(iEvent, getL1TEtSumParticleCollection_);
   fillTriggerObjectCollections<                      PFJetCollection>(iEvent, getPFJetCollection_);
   fillTriggerObjectCollections<                      PFTauCollection>(iEvent, getPFTauCollection_);
   fillTriggerObjectCollections<                      PFMETCollection>(iEvent, getPFMETCollection_);
   const unsigned int nk(tags_.size());
   LogDebug("TriggerSummaryProducerAOD") << "Number of collections found: " << nk;
   const unsigned int no(toc_.size());
   LogDebug("TriggerSummaryProducerAOD") << "Number of physics objects found: " << no;

   unique_ptr<TriggerEvent> product(new TriggerEvent(pn_,nk,no,nf));

   product->addCollections(tags_,keys_);
   product->addObjects(toc_);

   for (unsigned int ifob=0; ifob!=nfob; ++ifob) {
     if (maskFilters_[ifob]) {
       const string& label    (fobs[ifob].provenance()->moduleLabel());
       const string& instance (fobs[ifob].provenance()->productInstanceName());
       const string& process  (fobs[ifob].provenance()->processName());
       const edm::InputTag filterTag(label,instance,process);
       ids_.clear();
       keys_.clear();
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->photonIds()   ,fobs[ifob]->photonRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->electronIds() ,fobs[ifob]->electronRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->muonIds()     ,fobs[ifob]->muonRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->jetIds()      ,fobs[ifob]->jetRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->compositeIds(),fobs[ifob]->compositeRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->basemetIds()  ,fobs[ifob]->basemetRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->calometIds()  ,fobs[ifob]->calometRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->pixtrackIds() ,fobs[ifob]->pixtrackRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1emIds()     ,fobs[ifob]->l1emRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1muonIds()   ,fobs[ifob]->l1muonRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1jetIds()    ,fobs[ifob]->l1jetRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1etmissIds() ,fobs[ifob]->l1etmissRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1hfringsIds(),fobs[ifob]->l1hfringsRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1tmuonIds()  ,fobs[ifob]->l1tmuonRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1tegammaIds(),fobs[ifob]->l1tegammaRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1tjetIds()   ,fobs[ifob]->l1tjetRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1ttauIds()   ,fobs[ifob]->l1ttauRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->l1tetsumIds() ,fobs[ifob]->l1tetsumRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->pfjetIds()    ,fobs[ifob]->pfjetRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->pftauIds()    ,fobs[ifob]->pftauRefs());
       fillFilterObjectMembers(iEvent,filterTag,fobs[ifob]->pfmetIds()    ,fobs[ifob]->pfmetRefs());
       product->addFilter(filterTag,ids_,keys_);
     }
   }

   OrphanHandle<TriggerEvent> ref = iEvent.put(std::move(product));
   LogTrace("TriggerSummaryProducerAOD") << "Number of physics objects packed: " << ref->sizeObjects();
   LogTrace("TriggerSummaryProducerAOD") << "Number of filter  objects packed: " << ref->sizeFilters();

}

template <typename C>
void TriggerSummaryProducerAOD::fillTriggerObjectCollections(const edm::Event& iEvent, edm::GetterOfProducts<C>& getter) {


  using namespace std;
  using namespace edm;
  using namespace reco;
  using namespace l1extra;
  using namespace trigger;
  using namespace l1t;

  vector<Handle<C> > collections;
  getter.fillHandles(iEvent, collections);
  const unsigned int nc(collections.size());

  for (unsigned int ic=0; ic!=nc; ++ic) {
    const Provenance& provenance(*(collections[ic].provenance()));
    const string& label    (provenance.moduleLabel());
    const string& instance (provenance.productInstanceName());
    const string& process  (provenance.processName());
    const InputTag collectionTag(label,instance,process);

    if (collectionTagsEvent_.find(collectionTag)!=collectionTagsEvent_.end()) {
      const ProductID pid(collections[ic].provenance()->productID());
      if (offset_.find(pid)!=offset_.end()) {
    LogError("TriggerSummaryProducerAOD") << "Duplicate pid!";
      }
      offset_[pid]=toc_.size();
      const unsigned int n(collections[ic]->size());
      for (unsigned int i=0; i!=n; ++i) {
    fillTriggerObject( (*collections[ic])[i] );
      }
      tags_.push_back(collectionTag.encode());
      keys_.push_back(toc_.size());
    }

  } 
}

template <typename T>
void TriggerSummaryProducerAOD::fillTriggerObject(const T& object) {

  using namespace trigger;
  toc_.push_back( TriggerObject(object) );

  return;
}

void TriggerSummaryProducerAOD::fillTriggerObject(const l1extra::L1HFRings& object) {

  using namespace l1extra;
  using namespace trigger;

  toc_.push_back(TriggerObject(TriggerL1HfRingEtSums,
       object.hfEtSum(L1HFRings::kRing1PosEta),
       object.hfEtSum(L1HFRings::kRing1NegEta),
       object.hfEtSum(L1HFRings::kRing2PosEta),
       object.hfEtSum(L1HFRings::kRing2NegEta) ) );
  toc_.push_back(TriggerObject(TriggerL1HfBitCounts,
       object.hfBitCount(L1HFRings::kRing1PosEta),
       object.hfBitCount(L1HFRings::kRing1NegEta),
       object.hfBitCount(L1HFRings::kRing2PosEta),
       object.hfBitCount(L1HFRings::kRing2NegEta) ) );

  return;
}

void TriggerSummaryProducerAOD::fillTriggerObject(const l1extra::L1EtMissParticle& object) {

  using namespace l1extra;
  using namespace trigger;

  toc_.push_back( TriggerObject(object) );
  if (object.type()==L1EtMissParticle::kMET) {
    toc_.push_back(TriggerObject(TriggerL1ETT,object.etTotal(),0.0,0.0,0.0));
  } else if (object.type()==L1EtMissParticle::kMHT) {
    toc_.push_back(TriggerObject(TriggerL1HTT,object.etTotal(),0.0,0.0,0.0));
  } else {
    toc_.push_back(TriggerObject(0,           object.etTotal(),0.0,0.0,0.0));
  }

  return;
}

void TriggerSummaryProducerAOD::fillTriggerObject(const reco::PFMET& object) {

  using namespace reco;
  using namespace trigger;

  toc_.push_back( TriggerObject(object) );
  toc_.push_back(TriggerObject(TriggerTET    ,object.sumEt()         ,0.0,0.0,0.0));
  toc_.push_back(TriggerObject(TriggerMETSig ,object.mEtSig()        ,0.0,0.0,0.0));
  toc_.push_back(TriggerObject(TriggerELongit,object.e_longitudinal(),0.0,0.0,0.0));

  return;
}

void TriggerSummaryProducerAOD::fillTriggerObject(const reco::CaloMET& object) {

  using namespace reco;
  using namespace trigger;

  toc_.push_back( TriggerObject(object) );
  toc_.push_back(TriggerObject(TriggerTET    ,object.sumEt()         ,0.0,0.0,0.0));
  toc_.push_back(TriggerObject(TriggerMETSig ,object.mEtSig()        ,0.0,0.0,0.0));
  toc_.push_back(TriggerObject(TriggerELongit,object.e_longitudinal(),0.0,0.0,0.0));

  return;
}

void TriggerSummaryProducerAOD::fillTriggerObject(const reco::MET& object) {

  using namespace reco;
  using namespace trigger;

  toc_.push_back( TriggerObject(object) );
  toc_.push_back(TriggerObject(TriggerTHT    ,object.sumEt()         ,0.0,0.0,0.0));
  toc_.push_back(TriggerObject(TriggerMHTSig ,object.mEtSig()        ,0.0,0.0,0.0));
  toc_.push_back(TriggerObject(TriggerHLongit,object.e_longitudinal(),0.0,0.0,0.0));

  return;
}

template <typename C>
void TriggerSummaryProducerAOD::fillFilterObjectMembers(const edm::Event& iEvent, const edm::InputTag& tag, const trigger::Vids& ids, const std::vector<edm::Ref<C> >& refs) {


  using namespace std;
  using namespace edm;
  using namespace reco;
  using namespace l1extra;
  using namespace trigger;

  if (ids.size()!=refs.size()) {
    LogError("TriggerSummaryProducerAOD") << "Vector length is different: "
                      << ids.size() << " " << refs.size();
  }

  const unsigned int n(min(ids.size(),refs.size()));
  for (unsigned int i=0; i!=n; ++i) {
    const ProductID pid(refs[i].id());
    if (!(pid.isValid())) {
      LogError("TriggerSummaryProducerAOD")
    << "Iinvalid pid: " << pid
    << " FilterTag / Key: " << tag.encode()
    << " / " << i << "of" << n
    << " CollectionTag / Key: "
    << " <Unrecoverable>"
    << " / " << refs[i].key()
    << " CollectionType: " << typeid(C).name();
    } else if (offset_.find(pid)==offset_.end()) {
      const string&    label(iEvent.getProvenance(pid).moduleLabel());
      const string& instance(iEvent.getProvenance(pid).productInstanceName());
      const string&  process(iEvent.getProvenance(pid).processName());
      LogError("TriggerSummaryProducerAOD")
    << "Uunknown pid: " << pid
    << " FilterTag / Key: " << tag.encode()
    << " / " << i << "of" << n
    << " CollectionTag / Key: "
    << InputTag(label,instance,process).encode()
    << " / " << refs[i].key()
    << " CollectionType: " << typeid(C).name();
    } else {
      fillFilterObjectMember(offset_[pid],ids[i],refs[i]);
    }
  }
  return;

}

template <typename C>
void TriggerSummaryProducerAOD::fillFilterObjectMember(const int& offset, const int& id, const edm::Ref<C> & ref) {

  keys_.push_back(offset+ref.key());
  ids_.push_back(id);

  return;
}

void TriggerSummaryProducerAOD::fillFilterObjectMember(const int& offset, const int& id, const edm::Ref<l1extra::L1HFRingsCollection> & ref) {

  using namespace trigger;

  if (id==TriggerL1HfBitCounts) {
    keys_.push_back(offset+2*ref.key()+1);
  } else { // if (ids[i]==TriggerL1HfRingEtSums) {
    keys_.push_back(offset+2*ref.key()+0);
  }
  ids_.push_back(id);

  return;
}

void TriggerSummaryProducerAOD::fillFilterObjectMember(const int& offset, const int& id, const edm::Ref<l1extra::L1EtMissParticleCollection> & ref) {

  using namespace trigger;

  if ( (id==TriggerL1ETT) || (id==TriggerL1HTT) ) {
    keys_.push_back(offset+2*ref.key()+1);
  } else {
    keys_.push_back(offset+2*ref.key()+0);
  }
  ids_.push_back(id);

  return;
}

void TriggerSummaryProducerAOD::fillFilterObjectMember(const int& offset, const int& id, const edm::Ref<reco::PFMETCollection> & ref) {

  using namespace trigger;

  if ( (id==TriggerTHT) || (id==TriggerTET) ) {
    keys_.push_back(offset+4*ref.key()+1);
  } else if ( (id==TriggerMETSig) || (id==TriggerMHTSig) ) {
    keys_.push_back(offset+4*ref.key()+2);
  } else if ( (id==TriggerELongit) || (id==TriggerHLongit) ) {
    keys_.push_back(offset+4*ref.key()+3);
  } else {
    keys_.push_back(offset+4*ref.key()+0);
  }
  ids_.push_back(id);

  return;
}

void TriggerSummaryProducerAOD::fillFilterObjectMember(const int& offset, const int& id, const edm::Ref<reco::CaloMETCollection> & ref) {

  using namespace trigger;

  if ( (id==TriggerTHT) || (id==TriggerTET) ) {
    keys_.push_back(offset+4*ref.key()+1);
  } else if ( (id==TriggerMETSig) || (id==TriggerMHTSig) ) {
    keys_.push_back(offset+4*ref.key()+2);
  } else if ( (id==TriggerELongit) || (id==TriggerHLongit) ) {
    keys_.push_back(offset+4*ref.key()+3);
  } else {
    keys_.push_back(offset+4*ref.key()+0);
  }
  ids_.push_back(id);

  return;
}

void TriggerSummaryProducerAOD::fillFilterObjectMember(const int& offset, const int& id, const edm::Ref<reco::METCollection> & ref) {

  using namespace trigger;

  if ( (id==TriggerTHT) || (id==TriggerTET) ) {
    keys_.push_back(offset+4*ref.key()+1);
  } else if ( (id==TriggerMETSig) || (id==TriggerMHTSig) ) {
    keys_.push_back(offset+4*ref.key()+2);
  } else if ( (id==TriggerELongit) || (id==TriggerHLongit) ) {
    keys_.push_back(offset+4*ref.key()+3);
  } else {
    keys_.push_back(offset+4*ref.key()+0);
  }
  ids_.push_back(id);

  return;
}

void TriggerSummaryProducerAOD::endStream() {
  globalCache()->collectionTagsGlobal_.insert(collectionTagsStream_.begin(),collectionTagsStream_.end());
  globalCache()->filterTagsGlobal_.insert(filterTagsStream_.begin(),filterTagsStream_.end());
  return;
}

void TriggerSummaryProducerAOD::globalEndJob(const GlobalInputTags * globalInputTags) {

  using namespace std;
  using namespace edm;
  using namespace trigger;

  LogVerbatim("TriggerSummaryProducerAOD") << endl;
  LogVerbatim("TriggerSummaryProducerAOD") << "TriggerSummaryProducerAOD::globalEndJob - accumulated tags:" << endl;

  InputTagSet filterTags(false);
  InputTagSet collectionTags(false);

  filterTags.insert(globalInputTags->filterTagsGlobal_.begin(),globalInputTags->filterTagsGlobal_.end());
  collectionTags.insert(globalInputTags->collectionTagsGlobal_.begin(),globalInputTags->collectionTagsGlobal_.end());

  const unsigned int nc(collectionTags.size());
  const unsigned int nf(filterTags.size());
  LogVerbatim("TriggerSummaryProducerAOD") << " Overall number of Collections/Filters: "
          << nc << "/" << nf << endl;

  LogVerbatim("TriggerSummaryProducerAOD") << " The collections: " << nc << endl;
  const InputTagSet::const_iterator cb(collectionTags.begin());
  const InputTagSet::const_iterator ce(collectionTags.end());
  for ( InputTagSet::const_iterator ci=cb; ci!=ce; ++ci) {
    LogVerbatim("TriggerSummaryProducerAOD") << "  " << distance(cb,ci) << " " << ci->encode() << endl;
  }

  LogVerbatim("TriggerSummaryProducerAOD") << " The filters:" << nf << endl;
  const InputTagSet::const_iterator fb(filterTags.begin());
  const InputTagSet::const_iterator fe(filterTags.end());
  for ( InputTagSet::const_iterator fi=fb; fi!=fe; ++fi) {
    LogVerbatim("TriggerSummaryProducerAOD") << "  " << distance(fb,fi) << " " << fi->encode() << endl;
  }

  LogVerbatim("TriggerSummaryProducerAOD") << "TriggerSummaryProducerAOD::endJob." << endl;
  LogVerbatim("TriggerSummaryProducerAOD") << endl;

  return;

}