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_;
  boost::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_ != "" ) {
      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);