#include <EgammaRecHitExtractor.h>

Inheritance diagram for egammaisolation::EgammaRecHitExtractor:

Public Member Functions
virtual reco::IsoDeposit	deposit (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::Track &track) const

virtual reco::IsoDeposit	deposit (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::Candidate &c) const

	EgammaRecHitExtractor (const edm::ParameterSet &par, edm::ConsumesCollector &&iC)

	EgammaRecHitExtractor (const edm::ParameterSet &par, edm::ConsumesCollector &iC)

virtual void	fillVetos (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::TrackCollection &tracks)

virtual	~EgammaRecHitExtractor ()

Public Member Functions inherited from reco::isodeposit::IsoDepositExtractor
virtual reco::IsoDeposit	deposit (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::TrackBaseRef &track) const
	make single IsoDeposit based on trackRef as input More...

virtual reco::IsoDeposit	deposit (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::CandidateBaseRef &track) const
	make single IsoDeposit based on a CandidateBaseRef as input More...

virtual std::vector < reco::IsoDeposit >	deposits (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::Track &track) const

virtual std::vector < reco::IsoDeposit >	deposits (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::TrackBaseRef &track) const

virtual std::vector < reco::IsoDeposit >	deposits (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::Candidate &track) const

virtual std::vector < reco::IsoDeposit >	deposits (const edm::Event &ev, const edm::EventSetup &evSetup, const reco::CandidateBaseRef &track) const

virtual	~IsoDepositExtractor ()
	Destructor. More...

Private Member Functions
void	collect (reco::IsoDeposit &deposit, const reco::SuperClusterRef &sc, const CaloSubdetectorGeometry subdet, const CaloGeometry caloGeom, const EcalRecHitCollection &hits, const EcalSeverityLevelAlgo *sevLevel, bool barrel) const

Private Attributes
edm::InputTag	barrelEcalHitsTag_

edm::EDGetTokenT < EcalRecHitCollection >	barrelEcalHitsToken_

edm::InputTag	endcapEcalHitsTag_

edm::EDGetTokenT < EcalRecHitCollection >	endcapEcalHitsToken_

double	energyMin_

double	etMin_

double	extRadius_

bool	fakeNegativeDeposit_

std::vector< int >	flagsexclEB_

std::vector< int >	flagsexclEE_

double	intRadius_

double	intStrip_

bool	sameTag_

std::vector< int >	severitiesexclEB_

std::vector< int >	severitiesexclEE_

bool	tryBoth_

bool	useEt_

bool	vetoClustered_

Detailed Description

Definition at line 41 of file EgammaRecHitExtractor.h.

Constructor & Destructor Documentation

egammaisolation::EgammaRecHitExtractor::EgammaRecHitExtractor	(	const edm::ParameterSet &	par,
		edm::ConsumesCollector &&	iC
	)

inline

Definition at line 43 of file EgammaRecHitExtractor.h.

43 :

44 EgammaRecHitExtractor(par, iC) {}

egammaisolation::EgammaRecHitExtractor::EgammaRecHitExtractor

EgammaRecHitExtractor(const edm::ParameterSet &par, edm::ConsumesCollector &&iC)

Definition: EgammaRecHitExtractor.h:43

EgammaRecHitExtractor::EgammaRecHitExtractor	(	const edm::ParameterSet &	par,
		edm::ConsumesCollector &	iC
	)

Definition at line 41 of file EgammaRecHitExtractor.cc.

References barrelEcalHitsTag_, edm::InputTag::encode(), endcapEcalHitsTag_, edm::hlt::Exception, fakeNegativeDeposit_, flagsexclEB_, flagsexclEE_, edm::ParameterSet::getParameter(), intRadius_, sameTag_, severitiesexclEB_, severitiesexclEE_, AlCaHLTBitMon_QueryRunRegistry::string, tryBoth_, and useEt_.

                                                                                                   :
     etMin_(par.getParameter<double>("etMin")),
     energyMin_(par.getParameter<double>("energyMin")),
     extRadius_(par.getParameter<double>("extRadius")),
     intRadius_(par.getParameter<double>("intRadius")),
     intStrip_(par.getParameter<double>("intStrip")),
     barrelEcalHitsTag_(par.getParameter<edm::InputTag>("barrelEcalHits")),
     endcapEcalHitsTag_(par.getParameter<edm::InputTag>("endcapEcalHits")),
     barrelEcalHitsToken_(iC.consumes<EcalRecHitCollection>(barrelEcalHitsTag_)),
     endcapEcalHitsToken_(iC.consumes<EcalRecHitCollection>(endcapEcalHitsTag_)),
     fakeNegativeDeposit_(par.getParameter<bool>("subtractSuperClusterEnergy")),
     tryBoth_(par.getParameter<bool>("tryBoth")),
     vetoClustered_(par.getParameter<bool>("vetoClustered")),
     sameTag_(false)
     //severityLevelCut_(par.getParameter<int>("severityLevelCut"))
     //severityRecHitThreshold_(par.getParameter<double>("severityRecHitThreshold")),
     //spIdString_(par.getParameter<std::string>("spikeIdString")),
     //spIdThreshold_(par.getParameter<double>("spikeIdThreshold")),
 {
 
   const std::vector<std::string> flagnamesEB =
     par.getParameter<std::vector<std::string> >("RecHitFlagToBeExcludedEB");
 
   const std::vector<std::string> flagnamesEE =
     par.getParameter<std::vector<std::string> >("RecHitFlagToBeExcludedEE");
 
   flagsexclEB_=
     StringToEnumValue<EcalRecHit::Flags>(flagnamesEB);
 
   flagsexclEE_=
     StringToEnumValue<EcalRecHit::Flags>(flagnamesEE);
 
   const std::vector<std::string> severitynamesEB =
     par.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcludedEB");
 
   severitiesexclEB_=
     StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEB);
 
   const std::vector<std::string> severitynamesEE =
     par.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcludedEE");
 
   severitiesexclEE_=
     StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEE);
 
   if ((intRadius_ != 0.0) && (fakeNegativeDeposit_)) {
     throw cms::Exception("Configuration Error") << "EgammaRecHitExtractor: " <<
       "If you use 'subtractSuperClusterEnergy', you *must* set 'intRadius' to ZERO; it does not make sense, otherwise.";
   }
   std::string isoVariable = par.getParameter<std::string>("isolationVariable");
   if (isoVariable == "et") {
     useEt_ = true;
   } else if (isoVariable == "energy") {
     useEt_ = false;
   } else {
     throw cms::Exception("Configuration Error") << "EgammaRecHitExtractor: isolationVariable '" << isoVariable << "' not known. "
                         << " Supported values are 'et', 'energy'. ";
   }
   if (endcapEcalHitsTag_.encode() ==  barrelEcalHitsTag_.encode()) {
     sameTag_ = true;
     if (tryBoth_) {
       edm::LogWarning("EgammaRecHitExtractor") << "If you have configured 'barrelRecHits' == 'endcapRecHits', so I'm switching 'tryBoth' to FALSE.";
       tryBoth_ = false;
     }
   }
 }

EgammaRecHitExtractor::~EgammaRecHitExtractor ( )

virtual

Definition at line 107 of file EgammaRecHitExtractor.cc.

108 {}

Member Function Documentation

void EgammaRecHitExtractor::collect	(	reco::IsoDeposit &	deposit,
		const reco::SuperClusterRef &	sc,
		const CaloSubdetectorGeometry *	subdet,
		const CaloGeometry *	caloGeom,
		const EcalRecHitCollection &	hits,
		const EcalSeverityLevelAlgo *	sevLevel,
		bool	barrel
	)		const

private

Definition at line 166 of file EgammaRecHitExtractor.cc.

References reco::IsoDeposit::addDeposit(), reco::deltaPhi(), end, edm::SortedCollection< T, SORT >::end(), relval_parameters_module::energy, energyMin_, PV3DBase< T, PVType, FrameType >::eta(), eta(), etMin_, extRadius_, spr::find(), edm::SortedCollection< T, SORT >::find(), flagsexclEB_, flagsexclEE_, CaloSubdetectorGeometry::getCells(), CaloGeometry::getPosition(), i, intRadius_, intStrip_, j, EcalRecHit::kGood, PV3DBase< T, PVType, FrameType >::mag(), PV3DBase< T, PVType, FrameType >::perp(), phi, PV3DBase< T, PVType, FrameType >::phi(), position, diffTwoXMLs::r2, severitiesexclEB_, severitiesexclEE_, EcalSeverityLevelAlgo::severityLevel(), useEt_, and vetoClustered_.

Referenced by deposit().

                                                        {
 
   GlobalPoint caloPosition(sc->position().x(), sc->position().y() , sc->position().z());
   CaloSubdetectorGeometry::DetIdSet chosen = subdet->getCells(caloPosition,extRadius_);
   EcalRecHitCollection::const_iterator j=hits.end();
   double caloeta=caloPosition.eta();
   double calophi=caloPosition.phi();
   double r2 = intRadius_*intRadius_;
 
   std::vector< std::pair<DetId, float> >::const_iterator rhIt;
 
 
   for (CaloSubdetectorGeometry::DetIdSet::const_iterator i = chosen.begin(), end = chosen.end() ; i != end;  ++i)  {
     j = hits.find(*i);
     if (j != hits.end()) {
       const  GlobalPoint & position = caloGeom->getPosition(*i);
       double eta = position.eta();
       double phi = position.phi();
       double energy = j->energy();
       double et = energy*position.perp()/position.mag();
       double phiDiff= reco::deltaPhi(phi,calophi);
 
       //check if we are supposed to veto clustered and then do so
       if(vetoClustered_) {
 
     //Loop over basic clusters:
     bool isClustered = false;
     for(    reco::CaloCluster_iterator bcIt = sc->clustersBegin();bcIt != sc->clustersEnd(); ++bcIt) {
       for(rhIt = (*bcIt)->hitsAndFractions().begin();rhIt != (*bcIt)->hitsAndFractions().end(); ++rhIt) {
         if( rhIt->first == *i ) isClustered = true;
         if( isClustered ) break;
       }
       if( isClustered ) break;
     } //end loop over basic clusters
 
     if(isClustered) continue;
       }  //end if removeClustered
 
       std::vector<int>::const_iterator sit;
       int severityFlag = sevLevel->severityLevel(j->detid(), hits);
       if (barrel) {
     sit = std::find(severitiesexclEB_.begin(), severitiesexclEB_.end(), severityFlag);
     if (sit != severitiesexclEB_.end())
       continue;
       } else {
     sit = std::find(severitiesexclEE_.begin(), severitiesexclEE_.end(), severityFlag);
     if (sit != severitiesexclEE_.end())
       continue;
       }
 
       std::vector<int>::const_iterator vit;
       if (barrel) {
     // new rechit flag checks
     //vit = std::find(flagsexclEB_.begin(), flagsexclEB_.end(), ((EcalRecHit*)(&*j))->recoFlag());
     //if (vit != flagsexclEB_.end())
     //  continue;
     if (!((EcalRecHit*)(&*j))->checkFlag(EcalRecHit::kGood)) {
       if (((EcalRecHit*)(&*j))->checkFlags(flagsexclEB_)) {
         continue;
       }
     }
       } else {
     // new rechit flag checks
     //vit = std::find(flagsexclEE_.begin(), flagsexclEE_.end(), ((EcalRecHit*)(&*j))->recoFlag());
     //if (vit != flagsexclEE_.end())
     //  continue;
     if (!((EcalRecHit*)(&*j))->checkFlag(EcalRecHit::kGood)) {
       if (((EcalRecHit*)(&*j))->checkFlags(flagsexclEE_)) {
         continue;
       }
     }
       }
 
       if(et > etMin_
      && energy > energyMin_  //Changed to fabs - then changed back to energy
      && fabs(eta-caloeta) > intStrip_
      && (eta-caloeta)*(eta-caloeta) + phiDiff*phiDiff >r2 ) {
 
     deposit.addDeposit( Direction(eta, phi), (useEt_ ? et : energy));
       }
     }
   }
 }

virtual reco::IsoDeposit egammaisolation::EgammaRecHitExtractor::deposit	(	const edm::Event &	ev,
		const edm::EventSetup &	evSetup,
		const reco::Track &	track
	)		const

inlinevirtual

make single IsoDeposit based on track as input purely virtual: have to implement in concrete implementations

Implements reco::isodeposit::IsoDepositExtractor.

Definition at line 48 of file EgammaRecHitExtractor.h.

References edm::hlt::Exception, and mergeVDriftHistosByStation::name.

Referenced by deposit().

                                                                                                                       {
       throw cms::Exception("Configuration Error") << "This extractor " << (typeid(this).name()) << " is not made for tracks";
     }

reco::IsoDeposit EgammaRecHitExtractor::deposit	(	const edm::Event &	ev,
		const edm::EventSetup &	evSetup,
		const reco::Candidate &	track
	)		const

virtual

make single IsoDeposit based on a candidate as input purely virtual: have to implement in concrete implementations

Reimplemented from reco::isodeposit::IsoDepositExtractor.

Definition at line 110 of file EgammaRecHitExtractor.cc.

References funct::abs(), barrelEcalHitsToken_, collect(), deposit(), DetId::Ecal, EcalBarrel, EcalEndcap, endcapEcalHitsToken_, create_public_lumi_plots::exp, fakeNegativeDeposit_, edm::EventSetup::get(), reco::Candidate::get(), edm::Event::getByToken(), CaloGeometry::getSubdetectorGeometry(), intRadius_, metname, edm::ESHandle< class >::product(), sameTag_, funct::sin(), AlCaHLTBitMon_QueryRunRegistry::string, tryBoth_, and useEt_.

                                                                                             {
   edm::ESHandle<CaloGeometry> pG;
   iSetup.get<CaloGeometryRecord>().get(pG);
 
   //Get the channel status from the db
   //edm::ESHandle<EcalChannelStatus> chStatus;
   //iSetup.get<EcalChannelStatusRcd>().get(chStatus);
 
   edm::ESHandle<EcalSeverityLevelAlgo> sevlv;
   iSetup.get<EcalSeverityLevelAlgoRcd>().get(sevlv);
   const EcalSeverityLevelAlgo* sevLevel = sevlv.product();
 
   const CaloGeometry* caloGeom = pG.product();
   const CaloSubdetectorGeometry* barrelgeom = caloGeom->getSubdetectorGeometry(DetId::Ecal,EcalBarrel);
   const CaloSubdetectorGeometry* endcapgeom = caloGeom->getSubdetectorGeometry(DetId::Ecal,EcalEndcap);
 
   static std::string metname = "EgammaIsolationAlgos|EgammaRecHitExtractor";
 
   //Get barrel ECAL RecHits
   edm::Handle<EcalRecHitCollection> barrelEcalRecHitsH;
   iEvent.getByToken(barrelEcalHitsToken_, barrelEcalRecHitsH);
 
   //Get endcap ECAL RecHits
   edm::Handle<EcalRecHitCollection> endcapEcalRecHitsH;
   iEvent.getByToken(endcapEcalHitsToken_, endcapEcalRecHitsH);
 
   //define isodeposit starting from candidate
   reco::SuperClusterRef sc = emObject.get<reco::SuperClusterRef>();
   math::XYZPoint caloPosition = sc->position();
 
   Direction candDir(caloPosition.eta(), caloPosition.phi());
   reco::IsoDeposit deposit( candDir );
   deposit.setVeto( reco::IsoDeposit::Veto(candDir, intRadius_) );
   double sinTheta = sin(2*atan(exp(-sc->eta())));
   deposit.addCandEnergy(sc->energy() * (useEt_ ? sinTheta : 1.0)) ;
 
   // subtract supercluster if desired
   double fakeEnergy = -sc->rawEnergy();
   if (fakeNegativeDeposit_) {
     deposit.addDeposit(candDir, fakeEnergy * (useEt_ ?  sinTheta : 1.0)); // not exactly clean...
   }
 
   // fill rechits
   bool inBarrel = sameTag_ || ( abs(sc->eta()) < 1.479 ); //check for barrel. If only one collection is used, use barrel
   if (inBarrel || tryBoth_) {
     collect(deposit, sc, barrelgeom, caloGeom, *barrelEcalRecHitsH, sevLevel, true);
   }
 
   if ((!inBarrel) || tryBoth_) {
     collect(deposit, sc, endcapgeom, caloGeom, *endcapEcalRecHitsH, sevLevel, false);
   }
 
   return deposit;
 }

virtual void egammaisolation::EgammaRecHitExtractor::fillVetos	(	const edm::Event &	ev,
		const edm::EventSetup &	evSetup,
		const reco::TrackCollection &	tracks
	)