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);