ShiftedParticleProducerT.h

Go to the documentation of this file.

#ifndef PhysicsTools_PatUtils_ShiftedParticleProducerT_h
#define PhysicsTools_PatUtils_ShiftedParticleProducerT_h
 
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Utilities/interface/isFinite.h"
 
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"
#include "DataFormats/Candidate/interface/Candidate.h"
 
#include <string>
#include <vector>
 
template <typename T>
class ShiftedParticleProducerT : public edm::stream::EDProducer<> {
  typedef std::vector<T> ParticleCollection;
 
public:
  explicit ShiftedParticleProducerT(const edm::ParameterSet& cfg)
      : moduleLabel_(cfg.getParameter<std::string>("@module_label")) {
    srcToken_ = consumes<ParticleCollection>(cfg.getParameter<edm::InputTag>("src"));
 
    shiftBy_ = cfg.getParameter<double>("shiftBy");
 
    if (cfg.exists("binning")) {
      typedef std::vector<edm::ParameterSet> vParameterSet;
      vParameterSet cfgBinning = cfg.getParameter<vParameterSet>("binning");
      for (vParameterSet::const_iterator cfgBinningEntry = cfgBinning.begin(); cfgBinningEntry != cfgBinning.end();
           ++cfgBinningEntry) {
        binning_.push_back(new binningEntryType(*cfgBinningEntry));
      }
    } else {
      double uncertainty = cfg.getParameter<double>("uncertainty");
      binning_.push_back(new binningEntryType(uncertainty));
    }
 
    produces<ParticleCollection>();
  }
  ~ShiftedParticleProducerT() override {
    for (typename std::vector<binningEntryType*>::const_iterator it = binning_.begin(); it != binning_.end(); ++it) {
      delete (*it);
    }
  }
 
private:
  void produce(edm::Event& evt, const edm::EventSetup& es) override {
    edm::Handle<ParticleCollection> originalParticles;
    evt.getByToken(srcToken_, originalParticles);
 
    auto shiftedParticles = std::make_unique<ParticleCollection>();
 
    for (typename ParticleCollection::const_iterator originalParticle = originalParticles->begin();
         originalParticle != originalParticles->end();
         ++originalParticle) {
      double uncertainty = 0.;
      for (typename std::vector<binningEntryType*>::iterator binningEntry = binning_.begin();
           binningEntry != binning_.end();
           ++binningEntry) {
        if ((!(*binningEntry)->binSelection_) || (*(*binningEntry)->binSelection_)(*originalParticle)) {
          uncertainty = (*binningEntry)->binUncertainty_;
          break;
        }
      }
 
      double shift = shiftBy_ * uncertainty;
 
      reco::Candidate::LorentzVector shiftedParticleP4 = originalParticle->p4();
      //leave 0*nan = 0
      if (!(edm::isNotFinite(shift) && shiftedParticleP4.mag2() == 0))
        shiftedParticleP4 *= (1. + shift);
 
      T shiftedParticle(*originalParticle);
      shiftedParticle.setP4(shiftedParticleP4);
 
      shiftedParticles->push_back(shiftedParticle);
    }
 
    evt.put(std::move(shiftedParticles));
  }
 
  std::string moduleLabel_;
 
  edm::EDGetTokenT<ParticleCollection> srcToken_;
 
  struct binningEntryType {
    binningEntryType(double uncertainty) : binSelection_(nullptr), binUncertainty_(uncertainty) {}
    binningEntryType(const edm::ParameterSet& cfg)
        : binSelection_(new StringCutObjectSelector<T>(cfg.getParameter<std::string>("binSelection"))),
          binUncertainty_(cfg.getParameter<double>("binUncertainty")) {}
    ~binningEntryType() { delete binSelection_; }
    StringCutObjectSelector<T>* binSelection_;
    double binUncertainty_;
  };
  std::vector<binningEntryType*> binning_;
 
  double shiftBy_;  // set to +1.0/-1.0 for up/down variation of energy scale
};
 
#endif