MuScleFitMuonProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    MuScleFitMuonProducer
// Class:      MuScleFitMuonProducer
//
//
// Original Author:  Marco De Mattia,40 3-B32,+41227671551,
//         Created:  Tue Jun 22 13:50:22 CEST 2010
//
//

// system include files
#include <memory>
#include <string>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"

#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/Candidate/interface/LeafCandidate.h"

#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "DataFormats/PatCandidates/interface/CompositeCandidate.h"

#include "MuonAnalysis/MomentumScaleCalibration/interface/Functions.h"

#include "CondFormats/RecoMuonObjects/interface/MuScleFitDBobject.h"
#include "CondFormats/DataRecord/interface/MuScleFitDBobjectRcd.h"

#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "MuonAnalysis/MomentumScaleCalibration/interface/MomentumScaleCorrector.h"

class MuScleFitMuonProducer : public edm::EDProducer {
public:
  explicit MuScleFitMuonProducer(const edm::ParameterSet&);
  ~MuScleFitMuonProducer() override;

private:
  void beginJob() override;
  void produce(edm::Event&, const edm::EventSetup&) override;
  void endJob() override;
  template <class T>
  std::unique_ptr<T> applyCorrection(const edm::Handle<T>& allMuons);

  edm::InputTag theMuonLabel_;
  edm::EDGetTokenT<pat::MuonCollection> thePatMuonToken_;
  edm::EDGetTokenT<reco::MuonCollection> theRecoMuonToken_;
  bool patMuons_;
  edm::ESHandle<MuScleFitDBobject> dbObject_;
  std::string dbObjectLabel_;
  unsigned long long dbObjectCacheId_;
  std::shared_ptr<MomentumScaleCorrector> corrector_;
};

MuScleFitMuonProducer::MuScleFitMuonProducer(const edm::ParameterSet& iConfig)
    : theMuonLabel_(iConfig.getParameter<edm::InputTag>("MuonLabel")),
      thePatMuonToken_(mayConsume<pat::MuonCollection>(theMuonLabel_)),
      theRecoMuonToken_(mayConsume<reco::MuonCollection>(theMuonLabel_)),
      patMuons_(iConfig.getParameter<bool>("PatMuons")),
      dbObjectLabel_(iConfig.getUntrackedParameter<std::string>("DbObjectLabel", "")),
      dbObjectCacheId_(0) {
  if (patMuons_ == true) {
    produces<pat::MuonCollection>();
  } else {
    produces<reco::MuonCollection>();
  }
}

MuScleFitMuonProducer::~MuScleFitMuonProducer() {}

template <class T>
std::unique_ptr<T> MuScleFitMuonProducer::applyCorrection(const edm::Handle<T>& allMuons) {
  std::unique_ptr<T> pOut(new T);

  // Apply the correction and produce the new muons
  for (typename T::const_iterator muon = allMuons->begin(); muon != allMuons->end(); ++muon) {
    //std::cout << "Pt before correction = " << muon->pt() << std::endl;
    double pt = (*corrector_)(*muon);
    //std::cout << "Pt after correction = " << pt << std::endl;
    double eta = muon->eta();
    double phi = muon->phi();

    typename T::value_type* newMuon = muon->clone();
    newMuon->setP4(reco::Particle::PolarLorentzVector(pt, eta, phi, muon->mass()));

    pOut->push_back(*newMuon);
  }
  return pOut;
}

// ------------ method called to produce the data  ------------
void MuScleFitMuonProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  unsigned long long dbObjectCacheId = iSetup.get<MuScleFitDBobjectRcd>().cacheIdentifier();
  if (dbObjectCacheId != dbObjectCacheId_) {
    if (!dbObjectLabel_.empty()) {
      iSetup.get<MuScleFitDBobjectRcd>().get(dbObjectLabel_, dbObject_);
    } else {
      iSetup.get<MuScleFitDBobjectRcd>().get(dbObject_);
    }
  }

  //std::cout << "identifiers size from dbObject = " << dbObject_->identifiers.size() << std::endl;
  //std::cout << "parameters size from dbObject = " << dbObject_->parameters.size() << std::endl;;

  // Create the corrector and set the parameters
  corrector_.reset(new MomentumScaleCorrector(dbObject_.product()));

  if (patMuons_ == true) {
    edm::Handle<pat::MuonCollection> allMuons;
    iEvent.getByToken(thePatMuonToken_, allMuons);
    iEvent.put(applyCorrection(allMuons));
  } else {
    edm::Handle<reco::MuonCollection> allMuons;
    iEvent.getByToken(theRecoMuonToken_, allMuons);
    iEvent.put(applyCorrection(allMuons));
  }

  // put into the Event
  // iEvent.put(std::move(pOut));
  // iEvent.put(applyCorrection(allMuons);

  /*  std::unique_ptr<reco::MuonCollection> pOut(new reco::MuonCollection);

  // Apply the correction and produce the new muons
  for( std::vector<reco::Muon>::const_iterator muon = allMuons->begin(); muon != allMuons->end(); ++muon ) {

    double pt = (*corrector_)(*muon);
    double eta = muon->eta();
    double phi = muon->phi();

    reco::Muon * newMuon = muon->clone();
    newMuon->setP4( reco::Particle::PolarLorentzVector( pt, eta, phi, muon->mass() ) );

    pOut->push_back(*newMuon);
  }
*/
}

// ------------ method called once each job just before starting event loop  ------------
void MuScleFitMuonProducer::beginJob() {}

// ------------ method called once each job just after ending the event loop  ------------
void MuScleFitMuonProducer::endJob() {}

//define this as a plug-in
DEFINE_FWK_MODULE(MuScleFitMuonProducer);