EG9X105XObjectUpdateModifier.cc

Go to the documentation of this file.

#include "CommonTools/CandAlgos/interface/ModifyObjectValueBase.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/Framework/interface/ESHandle.h" 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/EgammaCandidates/interface/Photon.h"
#include "DataFormats/EgammaCandidates/interface/Conversion.h"
#include "RecoEcal/EgammaCoreTools/interface/EcalClusterTools.h"
#include "RecoEgamma/EgammaTools/interface/ConversionTools.h"


#include <vdt/vdtMath.h>

//this modifier fills variables where not present in CMSSW_92X to CMSSW_105X
//use case is when reading older new samples in newer releases, aka legacy
//note we suffer from the problem of needing to use the electrons/photons the valuemaps 
//are keyed to (something that is thankfully going away in 11X!) so we have to take 
//those collections in and figure out which ele/pho matches to them
class EG9X105XObjectUpdateModifier : public ModifyObjectValueBase {
public:
  template<typename T>
  class TokenHandlePair{
  public:
    TokenHandlePair(const edm::ParameterSet& conf, const std::string& name,edm::ConsumesCollector& cc):
      token_(cc.consumes<T>(conf.getParameter<edm::InputTag>(name))){}
    void setHandle(const edm::Event& iEvent){
      iEvent.getByToken(token_,handle_);
    }
    const edm::Handle<T>& handle()const{return handle_;}
  private:
    edm::EDGetTokenT<T> token_;
    edm::Handle<T> handle_;
  };

  EG9X105XObjectUpdateModifier(const edm::ParameterSet& conf, edm::ConsumesCollector& cc);
  ~EG9X105XObjectUpdateModifier() override{}
  
  void setEvent(const edm::Event&) final;
  void setEventContent(const edm::EventSetup&) final;
  
  void modifyObject(reco::GsfElectron& ele) const final;
  void modifyObject(reco::Photon& pho) const final;
  
  void modifyObject(pat::Electron& ele) const final{return modifyObject(static_cast<reco::GsfElectron&>(ele));}
  void modifyObject(pat::Photon& pho) const final{return modifyObject(static_cast<reco::Photon&>(pho));}
  
private:
  template<typename ObjType>
  static edm::Ptr<ObjType> getPtrForValueMap(const ObjType& obj,
                         const edm::Handle<edm::View<ObjType> >& objsVMIsKeyedTo);
  
  TokenHandlePair<edm::View<reco::GsfElectron> > eleCollVMsAreKeyedTo_;
  TokenHandlePair<edm::View<reco::Photon> > phoCollVMsAreKeyedTo_;

  TokenHandlePair<reco::ConversionCollection> conversions_;
  TokenHandlePair<reco::BeamSpot> beamspot_;
  TokenHandlePair<EcalRecHitCollection> ecalRecHitsEB_;
  TokenHandlePair<EcalRecHitCollection> ecalRecHitsEE_;
  
  TokenHandlePair<edm::ValueMap<float> > eleTrkIso_;
  TokenHandlePair<edm::ValueMap<float> > eleTrkIso04_;
  TokenHandlePair<edm::ValueMap<float> > phoPhotonIso_;
  TokenHandlePair<edm::ValueMap<float> > phoNeutralHadIso_;
  TokenHandlePair<edm::ValueMap<float> > phoChargedHadIso_;
  TokenHandlePair<edm::ValueMap<float> > phoChargedHadWorstVtxIso_;
  TokenHandlePair<edm::ValueMap<float> > phoChargedHadWorstVtxConeVetoIso_;
  TokenHandlePair<edm::ValueMap<float> > phoChargedHadPFPVIso_;
  //there is a bug which GsfTracks are now allowed to be a match for conversions
  //due to improper linking of references in the miniAOD since 94X
  //this allows us to emulate it or not
  //note: even if this enabled, it will do nothing on miniAOD produced with 94X, 102X 
  //till upto whenever this is fixed (11X?) as the GsfTrack references point to a different
  //collection to the conversion track references
  bool allowGsfTrkMatchForConvs_;
  //this allows us to update the charged hadron PF PV isolation
  //chargedHadPFPVIso is filled in iorules but when running on miniAOD, the value used in IDs
  //is remade on the miniAOD packedcandidates which differs due to rounding
  //its still the same variable but can have differences hence inorder to allow IDs calculated on miniAOD
  //on the same file to be exactly reproduced, this option is set true
  bool updateChargedHadPFPVIso_;
  
};

EG9X105XObjectUpdateModifier::EG9X105XObjectUpdateModifier(const edm::ParameterSet& conf, edm::ConsumesCollector& cc):
  ModifyObjectValueBase(conf),
  eleCollVMsAreKeyedTo_(conf,"eleCollVMsAreKeyedTo",cc),
  phoCollVMsAreKeyedTo_(conf,"phoCollVMsAreKeyedTo",cc),
  conversions_(conf,"conversions",cc),
  beamspot_(conf,"beamspot",cc),
  ecalRecHitsEB_(conf,"ecalRecHitsEB",cc),
  ecalRecHitsEE_(conf,"ecalRecHitsEE",cc),
  eleTrkIso_(conf,"eleTrkIso",cc),
  eleTrkIso04_(conf,"eleTrkIso04",cc),
  phoPhotonIso_(conf,"phoPhotonIso",cc),
  phoNeutralHadIso_(conf,"phoNeutralHadIso",cc),
  phoChargedHadIso_(conf,"phoChargedHadIso",cc),
  phoChargedHadWorstVtxIso_(conf,"phoChargedHadWorstVtxIso",cc),
  phoChargedHadWorstVtxConeVetoIso_(conf,"phoChargedHadWorstVtxConeVetoIso",cc),
  phoChargedHadPFPVIso_(conf,"phoChargedHadPFPVIso",cc),
  allowGsfTrkMatchForConvs_(conf.getParameter<bool>("allowGsfTrackForConvs")),
  updateChargedHadPFPVIso_(conf.getParameter<bool>("updateChargedHadPFPVIso"))
{
  

}

void EG9X105XObjectUpdateModifier::setEvent(const edm::Event& iEvent)
{
  eleCollVMsAreKeyedTo_.setHandle(iEvent);
  phoCollVMsAreKeyedTo_.setHandle(iEvent);
  conversions_.setHandle(iEvent);
  beamspot_.setHandle(iEvent);
  ecalRecHitsEB_.setHandle(iEvent);
  ecalRecHitsEE_.setHandle(iEvent);
  eleTrkIso_.setHandle(iEvent);
  eleTrkIso04_.setHandle(iEvent);
  phoPhotonIso_.setHandle(iEvent);
  phoNeutralHadIso_.setHandle(iEvent);
  phoChargedHadIso_.setHandle(iEvent);
  phoChargedHadWorstVtxIso_.setHandle(iEvent);
  phoChargedHadWorstVtxConeVetoIso_.setHandle(iEvent);
  if(updateChargedHadPFPVIso_) phoChargedHadPFPVIso_.setHandle(iEvent);
}

void EG9X105XObjectUpdateModifier::setEventContent(const edm::EventSetup& iSetup)
{

}

void EG9X105XObjectUpdateModifier::modifyObject(reco::GsfElectron& ele)const
{
  edm::Ptr<reco::GsfElectron> ptrForVM = getPtrForValueMap(ele,eleCollVMsAreKeyedTo_.handle());
  if(ptrForVM.isNull()){
    throw cms::Exception("LogicError") <<" in EG9X105ObjectUpdateModifier, line "<<__LINE__<<" electron "<<ele.et()<<" "<<ele.eta()<<" "<<ele.superCluster()->seed()->seed().rawId()<<" failed to match to the electrons the key map was keyed to, check the map collection is correct";
  }
  reco::GsfElectron::ConversionRejection convRejVars = ele.conversionRejectionVariables();
  if(allowGsfTrkMatchForConvs_){
    convRejVars.vtxFitProb = ConversionTools::getVtxFitProb(ConversionTools::matchedConversion(ele.core(),*conversions_.handle(),beamspot_.handle()->position()));
  }else{
    //its rather important to use the core function here to get the org trk ref
    convRejVars.vtxFitProb = ConversionTools::getVtxFitProb(ConversionTools::matchedConversion(ele.core()->ctfTrack(),*conversions_.handle(),beamspot_.handle()->position(),2.0,1e-6,0));
  }
  ele.setConversionRejectionVariables(convRejVars);
  
  reco::GsfElectron::IsolationVariables isolVars03 = ele.dr03IsolationVariables();
  isolVars03.tkSumPtHEEP = (*eleTrkIso_.handle())[ptrForVM];
  ele.setDr03Isolation(isolVars03);
  reco::GsfElectron::IsolationVariables isolVars04 = ele.dr04IsolationVariables();
  isolVars04.tkSumPtHEEP = (*eleTrkIso04_.handle())[ptrForVM];
  ele.setDr04Isolation(isolVars04);
}

void EG9X105XObjectUpdateModifier::modifyObject(reco::Photon& pho)const
{
  edm::Ptr<reco::Photon> ptrForVM = getPtrForValueMap(pho,phoCollVMsAreKeyedTo_.handle());
  if(ptrForVM.isNull()){
    throw cms::Exception("LogicError") <<" in EG9X105ObjectUpdateModifier, line "<<__LINE__<<" photon "<<pho.et()<<" "<<pho.eta()<<" "<<pho.superCluster()->seed()->seed().rawId()<<" failed to match to the photons the key map was keyed to, check the map collection is correct";
  }
  
  reco::Photon::PflowIsolationVariables pfIso = pho.getPflowIsolationVariables();
  pfIso.photonIso = (*phoPhotonIso_.handle())[ptrForVM];
  pfIso.neutralHadronIso = (*phoNeutralHadIso_.handle())[ptrForVM];
  pfIso.chargedHadronIso = (*phoChargedHadIso_.handle())[ptrForVM];
  pfIso.chargedHadronWorstVtxIso = (*phoChargedHadWorstVtxIso_.handle())[ptrForVM];
  pfIso.chargedHadronWorstVtxGeomVetoIso = (*phoChargedHadWorstVtxConeVetoIso_.handle())[ptrForVM];
  if(updateChargedHadPFPVIso_){
    pfIso.chargedHadronPFPVIso = (*phoChargedHadPFPVIso_.handle())[ptrForVM];
  }
  pho.setPflowIsolationVariables(pfIso);

  reco::Photon::ShowerShape fracSS = pho.showerShapeVariables();
  reco::Photon::ShowerShape fullSS = pho.full5x5_showerShapeVariables();

  const reco::CaloClusterPtr seedClus = pho.superCluster()->seed();
  const bool isEB = seedClus->seed().subdetId()==EcalBarrel;
  const auto& recHits = isEB ? *ecalRecHitsEB_.handle() : *ecalRecHitsEE_.handle();
  Cluster2ndMoments clus2ndMomFrac = EcalClusterTools::cluster2ndMoments(*seedClus,recHits);
  Cluster2ndMoments clus2ndMomFull = noZS::EcalClusterTools::cluster2ndMoments(*seedClus,recHits);
  fracSS.smMajor = clus2ndMomFrac.sMaj;
  fracSS.smMinor = clus2ndMomFrac.sMin;
  fracSS.smAlpha = clus2ndMomFrac.alpha;
  fullSS.smMajor = clus2ndMomFull.sMaj;
  fullSS.smMinor = clus2ndMomFull.sMin;
  fullSS.smAlpha = clus2ndMomFull.alpha;
  pho.setShowerShapeVariables(fracSS);
  pho.full5x5_setShowerShapeVariables(fullSS);

}

template<typename ObjType> edm::Ptr<ObjType> EG9X105XObjectUpdateModifier::
getPtrForValueMap(const ObjType& obj,
          const edm::Handle<edm::View<ObjType> >& objsVMIsKeyedTo)
{
  for(auto& objVMPtr : objsVMIsKeyedTo->ptrs()){
    if(obj.superCluster()->seed()->seed()==objVMPtr->superCluster()->seed()->seed()) return objVMPtr;
  }
  return edm::Ptr<ObjType>(objsVMIsKeyedTo.id()); //return null ptr if not found
}

  
DEFINE_EDM_PLUGIN(ModifyObjectValueFactory,
          EG9X105XObjectUpdateModifier,
          "EG9X105XObjectUpdateModifier");