PATObjectUserDataEmbedder.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/View.h"
 
#include "DataFormats/PatCandidates/interface/UserData.h"
#include "PhysicsTools/PatAlgos/interface/PATUserDataMerger.h"
 
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "DataFormats/PatCandidates/interface/Electron.h"
#include "DataFormats/PatCandidates/interface/Photon.h"
#include "DataFormats/PatCandidates/interface/Tau.h"
#include "DataFormats/PatCandidates/interface/Jet.h"
 
namespace pat {
 
  namespace helper {
 
    struct AddUserIntFromBool {
      typedef bool value_type;
      typedef edm::ValueMap<value_type> product_type;
      template <typename ObjectType>
      void addData(ObjectType &obj, const std::string &key, const value_type &val) {
        obj.addUserInt(key, val);
      }
    };
 
    template <typename A>
    class NamedUserDataLoader {
    public:
      NamedUserDataLoader(const edm::ParameterSet &iConfig, const std::string &main, edm::ConsumesCollector &&cc) {
        if (iConfig.existsAs<edm::ParameterSet>(main)) {
          edm::ParameterSet const &srcPSet = iConfig.getParameter<edm::ParameterSet>(main);
          for (const std::string &label : srcPSet.getParameterNamesForType<edm::InputTag>()) {
            labelsAndTokens_.emplace_back(
                label, cc.consumes<typename A::product_type>(srcPSet.getParameter<edm::InputTag>(label)));
          }
        }
      }
      template <typename T>
      void addData(const edm::Event &iEvent, const std::vector<edm::Ptr<T>> &ptrs, std::vector<T> &out) const {
        A adder;
        unsigned int n = ptrs.size();
        edm::Handle<typename A::product_type> handle;
        for (const auto &pair : labelsAndTokens_) {
          iEvent.getByToken(pair.second, handle);
          for (unsigned int i = 0; i < n; ++i) {
            adder.addData(out[i], pair.first, (*handle)[ptrs[i]]);
          }
        }
      }
 
    private:
      std::vector<std::pair<std::string, edm::EDGetTokenT<typename A::product_type>>> labelsAndTokens_;
    };  // class NamedUserDataLoader
  }     // namespace helper
 
  template <typename T>
  class PATObjectUserDataEmbedder : public edm::stream::EDProducer<> {
  public:
    explicit PATObjectUserDataEmbedder(const edm::ParameterSet &iConfig)
        : src_(consumes<edm::View<T>>(iConfig.getParameter<edm::InputTag>("src"))),
          userFloats_(iConfig, "userFloats", consumesCollector()),
          userInts_(iConfig, "userInts", consumesCollector()),
          userIntFromBools_(iConfig, "userIntFromBools", consumesCollector()),
          userCands_(iConfig, "userCands", consumesCollector()) {
      produces<std::vector<T>>();
    }
 
    ~PATObjectUserDataEmbedder() override {}
 
    void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override;
 
    static void fillDescriptions(edm::ConfigurationDescriptions &descriptions) {
      edm::ParameterSetDescription desc;
      desc.add<edm::InputTag>("src");
      for (const std::string &what : {"userFloats", "userInts", "userIntFromBools", "userCands"}) {
        edm::ParameterSetDescription descNested;
        descNested.addWildcard<edm::InputTag>("*");
        desc.add<edm::ParameterSetDescription>(what, descNested);
      }
      if (typeid(T) == typeid(pat::Muon))
        descriptions.add("muonsWithUserData", desc);
      else if (typeid(T) == typeid(pat::Electron))
        descriptions.add("electronsWithUserData", desc);
      else if (typeid(T) == typeid(pat::Photon))
        descriptions.add("photonsWithUserData", desc);
      else if (typeid(T) == typeid(pat::Tau))
        descriptions.add("tausWithUserData", desc);
      else if (typeid(T) == typeid(pat::Jet))
        descriptions.add("jetsWithUserData", desc);
    }
 
  private:
    // configurables
    edm::EDGetTokenT<edm::View<T>> src_;
    helper::NamedUserDataLoader<pat::helper::AddUserFloat> userFloats_;
    helper::NamedUserDataLoader<pat::helper::AddUserInt> userInts_;
    helper::NamedUserDataLoader<pat::helper::AddUserIntFromBool> userIntFromBools_;
    helper::NamedUserDataLoader<pat::helper::AddUserCand> userCands_;
  };
 
}  // namespace pat
 
template <typename T>
void pat::PATObjectUserDataEmbedder<T>::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
  edm::Handle<edm::View<T>> src;
  iEvent.getByToken(src_, src);
 
  std::unique_ptr<std::vector<T>> out(new std::vector<T>());
  out->reserve(src->size());
 
  std::vector<edm::Ptr<T>> ptrs;
  ptrs.reserve(src->size());
  for (unsigned int i = 0, n = src->size(); i < n; ++i) {
    // copy by value, save the ptr
    out->push_back((*src)[i]);
    ptrs.push_back(src->ptrAt(i));
  }
  userFloats_.addData(iEvent, ptrs, *out);
  userInts_.addData(iEvent, ptrs, *out);
  userIntFromBools_.addData(iEvent, ptrs, *out);
  userCands_.addData(iEvent, ptrs, *out);
 
  iEvent.put(std::move(out));
}
 
typedef pat::PATObjectUserDataEmbedder<pat::Electron> PATElectronUserDataEmbedder;
typedef pat::PATObjectUserDataEmbedder<pat::Muon> PATMuonUserDataEmbedder;
typedef pat::PATObjectUserDataEmbedder<pat::Photon> PATPhotonUserDataEmbedder;
typedef pat::PATObjectUserDataEmbedder<pat::Tau> PATTauUserDataEmbedder;
typedef pat::PATObjectUserDataEmbedder<pat::Jet> PATJetUserDataEmbedder;
 
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(PATElectronUserDataEmbedder);
DEFINE_FWK_MODULE(PATMuonUserDataEmbedder);
DEFINE_FWK_MODULE(PATPhotonUserDataEmbedder);
DEFINE_FWK_MODULE(PATTauUserDataEmbedder);
DEFINE_FWK_MODULE(PATJetUserDataEmbedder);