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"

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 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_;
  };

}




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