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"
#include "PhysicsTools/PatAlgos/interface/MuonMvaEstimator.h"
#include "PhysicsTools/PatAlgos/interface/SoftMuonMvaEstimator.h"
#include "DataFormats/PatCandidates/interface/TriggerObjectStandAlone.h"
#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/MuonReco/interface/MuonTimeExtra.h"

namespace pat {

  class PATMuonHeavyObjectCache {
  public:
    PATMuonHeavyObjectCache(const edm::ParameterSet&);

    std::unique_ptr<const pat::MuonMvaEstimator> const& muonMvaEstimator() const { return muonMvaEstimator_; }
    std::unique_ptr<const pat::MuonMvaEstimator> const& muonLowPtMvaEstimator() const { return muonLowPtMvaEstimator_; }

    std::unique_ptr<const pat::SoftMuonMvaEstimator> const& softMuonMvaEstimator() const {
      return softMuonMvaEstimator_;
    }

  private:
    std::unique_ptr<const pat::MuonMvaEstimator> muonLowPtMvaEstimator_;
    std::unique_ptr<const pat::MuonMvaEstimator> muonMvaEstimator_;
    std::unique_ptr<const pat::SoftMuonMvaEstimator> softMuonMvaEstimator_;
  };

  class TrackerIsolationPt;
  class CaloIsolationEnergy;

  class PATMuonProducer : public edm::stream::EDProducer<edm::GlobalCache<PATMuonHeavyObjectCache>> {
  public:
    explicit PATMuonProducer(const edm::ParameterSet& iConfig, PATMuonHeavyObjectCache const*);
    ~PATMuonProducer() override;

    static std::unique_ptr<PATMuonHeavyObjectCache> initializeGlobalCache(const edm::ParameterSet& iConfig) {
      return std::make_unique<PATMuonHeavyObjectCache>(iConfig);
    }

    static void globalEndJob(PATMuonHeavyObjectCache*) {}

    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);
    double getRelMiniIsoPUCorrected(const pat::Muon& muon, double rho, const std::vector<double>& area);

    double puppiCombinedIsolation(const pat::Muon& muon, const pat::PackedCandidateCollection* pc);
    bool isNeutralHadron(long pdgid);
    bool isChargedHadron(long pdgid);
    bool isPhoton(long pdgid);

    // 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);
    double relMiniIsoPUCorrected(const pat::Muon& aMuon, double rho);
    std::optional<GlobalPoint> getMuonDirection(const reco::MuonChamberMatch& chamberMatch,
                                                const edm::ESHandle<GlobalTrackingGeometry>& geometry,
                                                const DetId& chamberId);
    void fillL1TriggerInfo(pat::Muon& muon,
                           edm::Handle<std::vector<pat::TriggerObjectStandAlone>>& triggerObjects,
                           const edm::TriggerNames& names,
                           const edm::ESHandle<GlobalTrackingGeometry>& geometry);
    void fillHltTriggerInfo(pat::Muon& muon,
                            edm::Handle<std::vector<pat::TriggerObjectStandAlone>>& triggerObjects,
                            const edm::TriggerNames& names,
                            const std::vector<std::string>& collection_names);

  private:
    edm::EDGetTokenT<edm::View<reco::Muon>> muonToken_;

    // for mini-iso calculation
    edm::EDGetTokenT<pat::PackedCandidateCollection> pcToken_;
    bool computeMiniIso_;
    bool computePuppiCombinedIso_;
    std::vector<double> effectiveAreaVec_;
    std::vector<double> miniIsoParams_;
    double relMiniIsoPUCorrected_;

    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 addInverseBeta_;
    bool getdBFromTrack_;
    edm::EDGetTokenT<edm::ValueMap<reco::MuonTimeExtra>> muonTimeExtraToken_;
    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_;
    bool computeMuonMVA_;
    bool computeSoftMuonMVA_;
    bool recomputeBasicSelectors_;
    bool mvaUseJec_;
    edm::EDGetTokenT<reco::JetTagCollection> mvaBTagCollectionTag_;
    edm::EDGetTokenT<reco::JetCorrector> mvaL1Corrector_;
    edm::EDGetTokenT<reco::JetCorrector> mvaL1L2L3ResCorrector_;
    edm::EDGetTokenT<double> rho_;

    GreaterByPt<Muon> pTComparator_;
    pat::helper::MultiIsolator isolator_;
    pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_;
    pat::helper::EfficiencyLoader efficiencyLoader_;
    pat::PATUserDataHelper<pat::Muon> userDataHelper_;

    edm::EDGetTokenT<edm::ValueMap<reco::MuonSimInfo>> simInfo_;

    bool addTriggerMatching_;
    edm::EDGetTokenT<std::vector<pat::TriggerObjectStandAlone>> triggerObjects_;
    edm::EDGetTokenT<edm::TriggerResults> triggerResults_;
    std::vector<std::string> hltCollectionFilters_;
  };

}  // namespace pat

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