#include <AntiElectronDeadECAL.h>

Classes
struct	TowerInfo

Public Member Functions
	AntiElectronDeadECAL (const edm::ParameterSet &)

void	beginEvent (const edm::EventSetup &)

bool	operator() (const reco::Candidate *tau) const

	~AntiElectronDeadECAL ()

Private Member Functions
void	updateBadTowers (const edm::EventSetup &)

Private Attributes
std::vector< TowerInfo >	badTowers_

edm::ESWatcher< CaloGeometryRecord >	caloGeometryWatcher_

edm::ESWatcher< EcalChannelStatusRcd >	channelStatusWatcher_

const double	dR2_

const bool	extrapolateToECalEntrance_

edm::ESWatcher< IdealGeometryRecord >	idealGeometryWatcher_

bool	isFirstEvent_

const unsigned	minStatus_

PositionAtECalEntranceComputer	positionAtECalEntrance_

const int	verbosity_

Static Private Attributes
static const uint16_t	statusMask_ = 0x1F

Detailed Description

Flag tau candidates reconstructed near dead ECAL channels, in order to reduce e -> tau fakes not rejected by anti-e MVA discriminator

The motivation for this flag is this presentation: https://indico.cern.ch/getFile.py/access?contribId=0&resId=0&materialId=slides&confId=177223

Code adapted from: RecoTauTag/RecoTau/plugins/PFRecoTauDiscriminationAgainstElectronDeadECAL.cc

Authors: Lauri Andreas Wendland, Christian Veelken

Definition at line 35 of file AntiElectronDeadECAL.h.

Constructor & Destructor Documentation

AntiElectronDeadECAL::AntiElectronDeadECAL ( const edm::ParameterSet & cfg )

explicit

Definition at line 18 of file AntiElectronDeadECAL.cc.

     : minStatus_(cfg.getParameter<uint32_t>("minStatus")),
       dR2_(std::pow(cfg.getParameter<double>("dR"), 2)),
       extrapolateToECalEntrance_(cfg.getParameter<bool>("extrapolateToECalEntrance")),
       verbosity_(cfg.getParameter<int>("verbosity")),
       isFirstEvent_(true) {}

AntiElectronDeadECAL::~AntiElectronDeadECAL ( )

Definition at line 25 of file AntiElectronDeadECAL.cc.

25 {}

Member Function Documentation

void AntiElectronDeadECAL::beginEvent ( const edm::EventSetup & es )

Definition at line 27 of file AntiElectronDeadECAL.cc.

References PositionAtECalEntranceComputer::beginEvent(), EcalCondObjectContainer< T >::end(), PV3DBase< T, PVType, FrameType >::eta(), EcalCondObjectContainer< T >::find(), EcalCondObjectContainer< T >::getMap(), CaloGeometry::getPosition(), mps_fire::i, crabWrapper::key, SiStripPI::max, PATTauDiscriminationAgainstElectronDeadECAL_cfi::minStatus, PV3DBase< T, PVType, FrameType >::phi(), point, positionAtECalEntrance_, mps_update::status, EcalTrigTowerConstituentsMap::towerOf(), and updateBadTowers().

Referenced by TauDiscriminationAgainstElectronDeadECAL< TauType, TauDiscriminator >::beginEvent().

                                                              {
   updateBadTowers(es);
   positionAtECalEntrance_.beginEvent(es);
 }

bool AntiElectronDeadECAL::operator() ( const reco::Candidate * tau ) const

Definition at line 111 of file AntiElectronDeadECAL.cc.

References badTowers_, reco::deltaR2(), dR2_, reco::Candidate::eta(), extrapolateToECalEntrance_, edm::Ptr< T >::get(), edm::Ptr< T >::isNonnull(), pat::Tau::leadChargedHadrCand(), reco::PFTau::leadPFChargedHadrCand(), reco::Candidate::pdgId(), reco::Candidate::phi(), positionAtECalEntrance_, reco::Candidate::pt(), summarizeEdmComparisonLogfiles::success, metsig::tau, runTauDisplay::tau_eta, runTauDisplay::tau_phi, and verbosity_.

                                                                     {
   bool isNearBadTower = false;
   double tau_eta = tau->eta();
   double tau_phi = tau->phi();
   const reco::Candidate* leadChargedHadron = nullptr;
   if (extrapolateToECalEntrance_) {
     const reco::PFTau* pfTau = dynamic_cast<const reco::PFTau*>(tau);
     if (pfTau != nullptr) {
       leadChargedHadron = pfTau->leadPFChargedHadrCand().isNonnull() ? pfTau->leadPFChargedHadrCand().get() : nullptr;
     } else {
       const pat::Tau* patTau = dynamic_cast<const pat::Tau*>(tau);
       if (patTau != nullptr) {
         leadChargedHadron = patTau->leadChargedHadrCand().isNonnull() ? patTau->leadChargedHadrCand().get() : nullptr;
       }
     }
   }
   if (leadChargedHadron != nullptr) {
     bool success = false;
     reco::Candidate::Point positionAtECalEntrance = positionAtECalEntrance_(leadChargedHadron, success);
     if (success) {
       tau_eta = positionAtECalEntrance.eta();
       tau_phi = positionAtECalEntrance.phi();
     }
   }
   if (verbosity_) {
     edm::LogPrint("TauAgainstEleDeadECAL") << "<AntiElectronDeadECal::operator()>:";
     edm::LogPrint("TauAgainstEleDeadECAL") << " #badTowers = " << badTowers_.size();
     if (leadChargedHadron != nullptr) {
       edm::LogPrint("TauAgainstEleDeadECAL")
           << " leadChargedHadron (" << leadChargedHadron->pdgId() << "): Pt = " << leadChargedHadron->pt()
           << ", eta at ECAL (vtx) = " << tau_eta << " (" << leadChargedHadron->eta() << ")"
           << ", phi at ECAL (vtx) = " << tau_phi << " (" << leadChargedHadron->phi() << ")";
     } else {
       edm::LogPrint("TauAgainstEleDeadECAL")
           << " tau: Pt = " << tau->pt() << ", eta at vtx = " << tau_eta << ", phi at vtx = " << tau_phi;
     }
   }
   for (auto const& badTower : badTowers_) {
     if (deltaR2(badTower.eta_, badTower.phi_, tau_eta, tau_phi) < dR2_) {
       if (verbosity_) {
         edm::LogPrint("TauAgainstEleDeadECAL")
             << " matches badTower: eta = " << badTower.eta_ << ", phi = " << badTower.phi_;
       }
       isNearBadTower = true;
       break;
     }
   }
   return isNearBadTower;
 }

void AntiElectronDeadECAL::updateBadTowers ( const edm::EventSetup & es )

private

Definition at line 63 of file AntiElectronDeadECAL.cc.

References badTowers_, caloGeometryWatcher_, channelStatusWatcher_, edm::ESWatcher< T >::check(), edm::EventSetup::get(), idealGeometryWatcher_, isFirstEvent_, crabWrapper::key, minStatus_, edm::ESHandle< T >::product(), and statusMask_.

Referenced by beginEvent().

                                                                   {
   // NOTE: modified version of SUSY CAF code
   //         UserCode/SusyCAF/plugins/SusyCAF_EcalDeadChannels.cc
 
   if (!isFirstEvent_ && !channelStatusWatcher_.check(es) && !caloGeometryWatcher_.check(es) &&
       !idealGeometryWatcher_.check(es))
     return;
 
   edm::ESHandle<EcalChannelStatus> channelStatus;
   es.get<EcalChannelStatusRcd>().get(channelStatus);
 
   edm::ESHandle<CaloGeometry> caloGeometry;
   es.get<CaloGeometryRecord>().get(caloGeometry);
 
   edm::ESHandle<EcalTrigTowerConstituentsMap> ttMap;
   es.get<IdealGeometryRecord>().get(ttMap);
 
   std::map<uint32_t, unsigned> nBadCrystals, maxStatus;
   std::map<uint32_t, double> sumEta, sumPhi;
 
   loopXtals<EBDetId>(nBadCrystals,
                      maxStatus,
                      sumEta,
                      sumPhi,
                      channelStatus.product(),
                      caloGeometry.product(),
                      ttMap.product(),
                      minStatus_,
                      statusMask_);
   loopXtals<EEDetId>(nBadCrystals,
                      maxStatus,
                      sumEta,
                      sumPhi,
                      channelStatus.product(),
                      caloGeometry.product(),
                      ttMap.product(),
                      minStatus_,
                      statusMask_);
 
   badTowers_.clear();
   for (auto it : nBadCrystals) {
     uint32_t key = it.first;
     badTowers_.push_back(TowerInfo(key, it.second, maxStatus[key], sumEta[key] / it.second, sumPhi[key] / it.second));
   }
 
   isFirstEvent_ = false;
 }