PATMuonProducer.h

Go to the documentation of this file.

//
//

#ifndef PhysicsTools_PatAlgos_PATMuonProducer_h
#define PhysicsTools_PatAlgos_PATMuonProducer_h

#include <string>

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "CommonTools/Utils/interface/PtComparator.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "TrackingTools/IPTools/interface/IPTools.h"
#include "PhysicsTools/PatAlgos/interface/MultiIsolator.h"
#include "PhysicsTools/PatAlgos/interface/EfficiencyLoader.h"
#include "PhysicsTools/PatAlgos/interface/KinResolutionsLoader.h"

#include "DataFormats/PatCandidates/interface/UserData.h"
#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
#include "PhysicsTools/PatAlgos/interface/PATUserDataHelper.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"


namespace pat {
  class TrackerIsolationPt;
  class CaloIsolationEnergy;

  class PATMuonProducer : public edm::stream::EDProducer<> {

  public:
    explicit PATMuonProducer(const edm::ParameterSet & iConfig);
    ~PATMuonProducer();
    virtual void produce(edm::Event & iEvent, const edm::EventSetup& iSetup) override;
    static void fillDescriptions(edm::ConfigurationDescriptions & descriptions);

  private:
    typedef edm::RefToBase<reco::Muon> MuonBaseRef;
    typedef std::vector<edm::Handle<edm::Association<reco::GenParticleCollection> > > GenAssociations;
    typedef std::vector< edm::Handle< edm::ValueMap<IsoDeposit> > > IsoDepositMaps;
    typedef std::vector< edm::Handle< edm::ValueMap<double> > > IsolationValueMaps;
    typedef std::pair<pat::IsolationKeys,edm::InputTag> IsolationLabel;
    typedef std::vector<IsolationLabel> IsolationLabels;


      void fillMuon( Muon& aMuon, const MuonBaseRef& muonRef, const reco::CandidateBaseRef& baseRef, const GenAssociations& genMatches, const IsoDepositMaps& deposits, const IsolationValueMaps& isolationValues) const;
    template<typename T> void readIsolationLabels( const edm::ParameterSet & iConfig, const char* psetName, IsolationLabels& labels, std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > & tokens);

      void setMuonMiniIso(pat::Muon& aMuon, const pat::PackedCandidateCollection *pc);

    // embed various impact parameters with errors
    // embed high level selection
    void embedHighLevel( pat::Muon & aMuon,
             reco::TrackRef track,
             reco::TransientTrack & tt,
             reco::Vertex & primaryVertex,
             bool primaryVertexIsValid,
             reco::BeamSpot & beamspot,
             bool beamspotIsValid );


  private:
    edm::EDGetTokenT<edm::View<reco::Muon> > muonToken_;
    
    // for mini-iso calculation
    edm::EDGetTokenT<pat::PackedCandidateCollection > pcToken_;
    bool computeMiniIso_;
    std::vector<double> miniIsoParams_;

    bool embedBestTrack_;
    bool embedTunePBestTrack_;
    bool forceEmbedBestTrack_;
    bool embedTrack_;
    bool embedStandAloneMuon_;
    bool embedCombinedMuon_;
    bool embedCaloMETMuonCorrs_;
    edm::EDGetTokenT<edm::ValueMap<reco::MuonMETCorrectionData> > caloMETMuonCorrsToken_;
    bool embedTcMETMuonCorrs_;
    edm::EDGetTokenT<edm::ValueMap<reco::MuonMETCorrectionData> > tcMETMuonCorrsToken_;
    bool embedPickyMuon_;
    bool embedTpfmsMuon_;
    bool embedDytMuon_;
    bool addGenMatch_;
    std::vector<edm::EDGetTokenT<edm::Association<reco::GenParticleCollection> > > genMatchTokens_;
    bool embedGenMatch_;
    bool addResolutions_;
    pat::helper::KinResolutionsLoader resolutionLoader_;
    bool useParticleFlow_;
    edm::EDGetTokenT<reco::PFCandidateCollection> pfMuonToken_;
    bool embedPFCandidate_;
    bool embedHighLevelSelection_;
    edm::EDGetTokenT<reco::BeamSpot> beamLineToken_;
    edm::EDGetTokenT<std::vector<reco::Vertex> > pvToken_;
    IsolationLabels isoDepositLabels_;
    std::vector<edm::EDGetTokenT<edm::ValueMap<IsoDeposit> > > isoDepositTokens_;
    IsolationLabels isolationValueLabels_;
    std::vector<edm::EDGetTokenT<edm::ValueMap<double> > > isolationValueTokens_;
    bool addEfficiencies_;
    bool useUserData_;
    bool embedPfEcalEnergy_;
    bool addPuppiIsolation_;
    //PUPPI isolation tokens
    edm::EDGetTokenT<edm::ValueMap<float> > PUPPIIsolation_charged_hadrons_;
    edm::EDGetTokenT<edm::ValueMap<float> > PUPPIIsolation_neutral_hadrons_;
    edm::EDGetTokenT<edm::ValueMap<float> > PUPPIIsolation_photons_;
    //PUPPINoLeptons isolation tokens
    edm::EDGetTokenT<edm::ValueMap<float> > PUPPINoLeptonsIsolation_charged_hadrons_;
    edm::EDGetTokenT<edm::ValueMap<float> > PUPPINoLeptonsIsolation_neutral_hadrons_;
    edm::EDGetTokenT<edm::ValueMap<float> > PUPPINoLeptonsIsolation_photons_;
    
    GreaterByPt<Muon> pTComparator_;
    pat::helper::MultiIsolator isolator_;
    pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_;
    pat::helper::EfficiencyLoader efficiencyLoader_;
    pat::PATUserDataHelper<pat::Muon> userDataHelper_;
  };

}




template<typename T>
void pat::PATMuonProducer::readIsolationLabels( const edm::ParameterSet & iConfig, const char* psetName, pat::PATMuonProducer::IsolationLabels& labels, std::vector<edm::EDGetTokenT<edm::ValueMap<T> > > & tokens)
{
  labels.clear();

  if (iConfig.exists( psetName )) {
    edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>(psetName);

    if (depconf.exists("tracker")) labels.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
    if (depconf.exists("ecal"))    labels.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
    if (depconf.exists("hcal"))    labels.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
    if (depconf.exists("pfAllParticles"))  {
      labels.push_back(std::make_pair(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles")));
    }
    if (depconf.exists("pfChargedHadrons"))  {
      labels.push_back(std::make_pair(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons")));
    }
    if (depconf.exists("pfChargedAll"))  {
      labels.push_back(std::make_pair(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll")));
    }
    if (depconf.exists("pfPUChargedHadrons"))  {
      labels.push_back(std::make_pair(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons")));
    }
    if (depconf.exists("pfNeutralHadrons"))  {
      labels.push_back(std::make_pair(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons")));
    }
    if (depconf.exists("pfPhotons")) {
      labels.push_back(std::make_pair(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfPhotons")));
    }
    if (depconf.exists("user")) {
      std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag> >("user");
      std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
      int key = pat::IsolationKeys::UserBaseIso;
      for ( ; it != ed; ++it, ++key) {
       labels.push_back(std::make_pair(pat::IsolationKeys(key), *it));
      }
      tokens = edm::vector_transform(labels, [this](IsolationLabel const & label){return consumes<edm::ValueMap<T> >(label.second);});
    }
  }
  tokens = edm::vector_transform(labels, [this](pat::PATMuonProducer::IsolationLabel const & label){return consumes<edm::ValueMap<T> >(label.second);});
}

#endif