#include <HBHEIsolatedNoiseReflagger.h>

Inheritance diagram for HBHEIsolatedNoiseReflagger:

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

	~HBHEIsolatedNoiseReflagger ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
void	DumpHBHEHitMap (std::vector< HBHEHitMap > &i) const

virtual void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
bool	debug_

double	LooseDiHitEne_

double	LooseEcalIsol_

double	LooseHcalIsol_

double	LooseHPDEne1_

double	LooseHPDEne2_

int	LooseHPDHits1_

int	LooseHPDHits2_

double	LooseMonoHitEne_

double	LooseRBXEne1_

double	LooseRBXEne2_

int	LooseRBXHits1_

int	LooseRBXHits2_

double	LooseTrackIsol_

ObjectValidator	objvalidator_

double	TightDiHitEne_

double	TightEcalIsol_

double	TightHcalIsol_

double	TightHPDEne1_

double	TightHPDEne2_

int	TightHPDHits1_

int	TightHPDHits2_

double	TightMonoHitEne_

double	TightRBXEne1_

double	TightRBXEne2_

int	TightRBXHits1_

int	TightRBXHits2_

double	TightTrackIsol_

edm::EDGetTokenT < EcalRecHitCollection >	tok_EB_

edm::EDGetTokenT < EcalRecHitCollection >	tok_EE_

edm::EDGetTokenT < HBHERecHitCollection >	tok_hbhe_

edm::EDGetTokenT< std::vector < reco::TrackExtrapolation > >	tok_trackExt_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 19 of file HBHEIsolatedNoiseReflagger.h.

Constructor & Destructor Documentation

HBHEIsolatedNoiseReflagger::HBHEIsolatedNoiseReflagger ( const edm::ParameterSet & iConfig )

explicit

Definition at line 24 of file HBHEIsolatedNoiseReflagger.cc.

References edm::ParameterSet::getParameter(), tok_EB_, tok_EE_, tok_hbhe_, and tok_trackExt_.

                                                                                      :
   
   LooseHcalIsol_(iConfig.getParameter<double>("LooseHcalIsol")),
   LooseEcalIsol_(iConfig.getParameter<double>("LooseEcalIsol")),
   LooseTrackIsol_(iConfig.getParameter<double>("LooseTrackIsol")),
   TightHcalIsol_(iConfig.getParameter<double>("TightHcalIsol")),
   TightEcalIsol_(iConfig.getParameter<double>("TightEcalIsol")),
   TightTrackIsol_(iConfig.getParameter<double>("TightTrackIsol")),
 
   LooseRBXEne1_(iConfig.getParameter<double>("LooseRBXEne1")),
   LooseRBXEne2_(iConfig.getParameter<double>("LooseRBXEne2")),
   LooseRBXHits1_(iConfig.getParameter<int>("LooseRBXHits1")),
   LooseRBXHits2_(iConfig.getParameter<int>("LooseRBXHits2")),
   TightRBXEne1_(iConfig.getParameter<double>("TightRBXEne1")),
   TightRBXEne2_(iConfig.getParameter<double>("TightRBXEne2")),
   TightRBXHits1_(iConfig.getParameter<int>("TightRBXHits1")),
   TightRBXHits2_(iConfig.getParameter<int>("TightRBXHits2")),
 
   LooseHPDEne1_(iConfig.getParameter<double>("LooseHPDEne1")),
   LooseHPDEne2_(iConfig.getParameter<double>("LooseHPDEne2")),
   LooseHPDHits1_(iConfig.getParameter<int>("LooseHPDHits1")),
   LooseHPDHits2_(iConfig.getParameter<int>("LooseHPDHits2")),
   TightHPDEne1_(iConfig.getParameter<double>("TightHPDEne1")),
   TightHPDEne2_(iConfig.getParameter<double>("TightHPDEne2")),
   TightHPDHits1_(iConfig.getParameter<int>("TightHPDHits1")),
   TightHPDHits2_(iConfig.getParameter<int>("TightHPDHits2")),
 
   LooseDiHitEne_(iConfig.getParameter<double>("LooseDiHitEne")),
   TightDiHitEne_(iConfig.getParameter<double>("TightDiHitEne")),
   LooseMonoHitEne_(iConfig.getParameter<double>("LooseMonoHitEne")),
   TightMonoHitEne_(iConfig.getParameter<double>("TightMonoHitEne")),
   
   debug_(iConfig.getUntrackedParameter<bool>("debug",true)),
   objvalidator_(iConfig)
 {
 
   tok_hbhe_ = consumes<HBHERecHitCollection>(iConfig.getParameter<edm::InputTag>("hbheInput"));
   tok_EB_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("ebInput"));
   tok_EE_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("eeInput"));
   tok_trackExt_ = consumes<std::vector<reco::TrackExtrapolation> >(iConfig.getParameter<edm::InputTag>("trackExtrapolationInput"));
 
   produces<HBHERecHitCollection>();
 }

HBHEIsolatedNoiseReflagger::~HBHEIsolatedNoiseReflagger ( )

Definition at line 68 of file HBHEIsolatedNoiseReflagger.cc.

69 {

70 }

Member Function Documentation

void HBHEIsolatedNoiseReflagger::DumpHBHEHitMap ( std::vector< HBHEHitMap > & i ) const

private

Definition at line 227 of file HBHEIsolatedNoiseReflagger.cc.

References HBHERecHit::id(), HcalHPDRBXMap::indexHPD(), and HcalHPDRBXMap::indexRBX().

Referenced by produce().

 {
   for(std::vector<HBHEHitMap>::const_iterator it=i.begin(); it!=i.end(); ++it) {
     edm::LogInfo("HBHEIsolatedNoiseReflagger") << "hit energy=" << it->hitEnergy()
           << "; # hits=" << it->nHits()
           << "; hcal energy same=" << it->hcalEnergySameTowers()
                     << "; ecal energy same=" << it->ecalEnergySameTowers()
                   << "; track energy same=" << it->trackEnergySameTowers()
                   << "; neighbor hcal energy=" << it->hcalEnergyNeighborTowers() << std::endl;
         edm::LogInfo("HBHEIsolatedNoiseReflagger") << "hits:" << std::endl;
         for(HBHEHitMap::hitmap_const_iterator it2=it->beginHits(); it2!=it->endHits(); ++it2) {
           const HBHERecHit *hit=it2->first;
             edm::LogInfo("HBHEIsolatedNoiseReflagger") << "RBX #=" << HcalHPDRBXMap::indexRBX(hit->id())
                       << "; HPD #=" << HcalHPDRBXMap::indexHPD(hit->id())
                       << "; " << (*hit) << std::endl;
         }
   }
   return;
 }

void HBHEIsolatedNoiseReflagger::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	evSetup
	)

overrideprivatevirtual

Implements edm::stream::EDProducerBase.

Definition at line 74 of file HBHEIsolatedNoiseReflagger.cc.

References debug_, DumpHBHEHitMap(), edm::EventSetup::get(), edm::Event::getByToken(), HBHEHitMapOrganizer::getDiHits(), HBHEHitMapOrganizer::getHPDs(), HBHEHitMapOrganizer::getMonoHits(), HBHEHitMapOrganizer::getRBXs(), HcalCaloFlagLabels::HBHEIsolatedNoise, i, LooseDiHitEne_, LooseEcalIsol_, LooseHcalIsol_, LooseHPDEne1_, LooseHPDEne2_, LooseHPDHits1_, LooseHPDHits2_, LooseMonoHitEne_, LooseRBXEne1_, LooseRBXEne2_, LooseRBXHits1_, LooseRBXHits2_, LooseTrackIsol_, nhits, objvalidator_, edm::ESHandle< class >::product(), edm::Event::put(), ObjectValidator::setEBRecHitCollection(), ObjectValidator::setEcalChannelStatus(), ObjectValidator::setEcalSeverityLevelAlgo(), ObjectValidator::setEERecHitCollection(), CaloRecHit::setFlagField(), ObjectValidator::setHcalChannelQuality(), ObjectValidator::setHcalSeverityLevelComputer(), TightDiHitEne_, TightEcalIsol_, TightHcalIsol_, TightHPDEne1_, TightHPDEne2_, TightHPDHits1_, TightHPDHits2_, TightMonoHitEne_, TightRBXEne1_, TightRBXEne2_, TightRBXHits1_, TightRBXHits2_, TightTrackIsol_, tok_EB_, tok_EE_, tok_hbhe_, and tok_trackExt_.

 {
   // get the ECAL channel status map
   edm::ESHandle<EcalChannelStatus> ecalChStatus;
   evSetup.get<EcalChannelStatusRcd>().get( ecalChStatus );
   const EcalChannelStatus* dbEcalChStatus = ecalChStatus.product();
 
   // get the HCAL channel status map
 
   edm::ESHandle<HcalChannelQuality> hcalChStatus;    
   evSetup.get<HcalChannelQualityRcd>().get( "withTopo", hcalChStatus );
   const HcalChannelQuality* dbHcalChStatus = hcalChStatus.product();
 
   // get the severity level computers
   edm::ESHandle<HcalSeverityLevelComputer> hcalSevLvlComputerHndl;
   evSetup.get<HcalSeverityLevelComputerRcd>().get(hcalSevLvlComputerHndl);
   const HcalSeverityLevelComputer* hcalSevLvlComputer = hcalSevLvlComputerHndl.product();
 
   edm::ESHandle<EcalSeverityLevelAlgo> ecalSevLvlAlgoHndl;
   evSetup.get<EcalSeverityLevelAlgoRcd>().get(ecalSevLvlAlgoHndl);
   const EcalSeverityLevelAlgo* ecalSevLvlAlgo = ecalSevLvlAlgoHndl.product();
 
   // get the calotower mappings
   edm::ESHandle<CaloTowerConstituentsMap> ctcm;
   evSetup.get<CaloGeometryRecord>().get(ctcm);
   
   // get the HB/HE hits
   edm::Handle<HBHERecHitCollection> hbhehits_h;
   iEvent.getByToken(tok_hbhe_, hbhehits_h);
 
   // get the ECAL hits
   edm::Handle<EcalRecHitCollection> ebhits_h;
   iEvent.getByToken(tok_EB_, ebhits_h);
   edm::Handle<EcalRecHitCollection> eehits_h;
   iEvent.getByToken(tok_EE_, eehits_h);
 
   // get the tracks
   edm::Handle<std::vector<reco::TrackExtrapolation> > trackextraps_h;
   iEvent.getByToken(tok_trackExt_, trackextraps_h);
 
   // set the status maps and severity level computers for the hit validator
   objvalidator_.setHcalChannelQuality(dbHcalChStatus);
   objvalidator_.setEcalChannelStatus(dbEcalChStatus);
   objvalidator_.setHcalSeverityLevelComputer(hcalSevLvlComputer);
   objvalidator_.setEcalSeverityLevelAlgo(ecalSevLvlAlgo);
   objvalidator_.setEBRecHitCollection(&(*ebhits_h));
   objvalidator_.setEERecHitCollection(&(*eehits_h));
 
   // organizer the hits
   PhysicsTowerOrganizer pto(iEvent, evSetup, hbhehits_h, ebhits_h, eehits_h, trackextraps_h, objvalidator_, *(ctcm.product()));
   HBHEHitMapOrganizer organizer(hbhehits_h, objvalidator_, pto);
 
   // get the rbxs, hpds, dihits, and monohits
   std::vector<HBHEHitMap> rbxs;
   std::vector<HBHEHitMap> hpds;
   std::vector<HBHEHitMap> dihits;
   std::vector<HBHEHitMap> monohits;
   organizer.getRBXs(rbxs, LooseRBXEne1_<TightRBXEne1_ ? LooseRBXEne1_ : TightRBXEne1_);
   organizer.getHPDs(hpds, LooseHPDEne1_<TightHPDEne1_ ? LooseHPDEne1_ : TightHPDEne1_);
   organizer.getDiHits(dihits, LooseDiHitEne_<TightDiHitEne_ ? LooseDiHitEne_ : TightDiHitEne_);
   organizer.getMonoHits(monohits, LooseMonoHitEne_<TightMonoHitEne_ ? LooseMonoHitEne_ : TightMonoHitEne_);
 
   if(debug_ && (rbxs.size()>0 || hpds.size()>0 || dihits.size()>0 || monohits.size()>0)) {
     edm::LogInfo("HBHEIsolatedNoiseReflagger") << "RBXs:" << std::endl;
     DumpHBHEHitMap(rbxs);
     edm::LogInfo("HBHEIsolatedNoiseReflagger") << "\nHPDs:" << std::endl;
     DumpHBHEHitMap(hpds);
     edm::LogInfo("HBHEIsolatedNoiseReflagger") << "\nDiHits:" << std::endl;
     DumpHBHEHitMap(dihits);
     edm::LogInfo("HBHEIsolatedNoiseReflagger") << "\nMonoHits:" << std::endl;
     DumpHBHEHitMap(monohits);
   }
 
   //  bool result=true;
 
   // determine which hits are noisy
   std::set<const HBHERecHit*> noisehits;
   for(int i=0; i<static_cast<int>(rbxs.size()); i++) {
     int nhits=rbxs[i].nHits();
     double ene=rbxs[i].hitEnergy();
     double trkfide=rbxs[i].hitEnergyTrackFiducial();
     double isolhcale=rbxs[i].hcalEnergySameTowers()+rbxs[i].hcalEnergyNeighborTowers();
     double isolecale=rbxs[i].ecalEnergySameTowers();
     double isoltrke=rbxs[i].trackEnergySameTowers()+rbxs[i].trackEnergyNeighborTowers();
     if((isolhcale/ene<LooseHcalIsol_ && isolecale/ene<LooseEcalIsol_ && isoltrke/ene<LooseTrackIsol_ && ((trkfide>LooseRBXEne1_ && nhits>=LooseRBXHits1_) || (trkfide>LooseRBXEne2_ && nhits>=LooseRBXHits2_))) ||
        (isolhcale/ene<TightHcalIsol_ && isolecale/ene<TightEcalIsol_ && isoltrke/ene<TightTrackIsol_ && ((trkfide>TightRBXEne1_ && nhits>=TightRBXHits1_) || (trkfide>TightRBXEne2_ && nhits>=TightRBXHits2_)))) {
       for(HBHEHitMap::hitmap_const_iterator it=rbxs[i].beginHits(); it!=rbxs[i].endHits(); ++it)
     noisehits.insert(it->first);
       //      result=false;
     }
   }
 
   for(int i=0; i<static_cast<int>(hpds.size()); i++) {
     int nhits=hpds[i].nHits();
     double ene=hpds[i].hitEnergy();
     double trkfide=hpds[i].hitEnergyTrackFiducial();
     double isolhcale=hpds[i].hcalEnergySameTowers()+hpds[i].hcalEnergyNeighborTowers();
     double isolecale=hpds[i].ecalEnergySameTowers();
     double isoltrke=hpds[i].trackEnergySameTowers()+hpds[i].trackEnergyNeighborTowers();
     if((isolhcale/ene<LooseHcalIsol_ && isolecale/ene<LooseEcalIsol_ && isoltrke/ene<LooseTrackIsol_ && ((trkfide>LooseHPDEne1_ && nhits>=LooseHPDHits1_) || (trkfide>LooseHPDEne2_ && nhits>=LooseHPDHits2_))) ||
        (isolhcale/ene<TightHcalIsol_ && isolecale/ene<TightEcalIsol_ && isoltrke/ene<TightTrackIsol_ && ((trkfide>TightHPDEne1_ && nhits>=TightHPDHits1_) || (trkfide>TightHPDEne2_ && nhits>=TightHPDHits2_)))) {
       for(HBHEHitMap::hitmap_const_iterator it=hpds[i].beginHits(); it!=hpds[i].endHits(); ++it)
     noisehits.insert(it->first);
       //      result=false;
     }
   }
 
   for(int i=0; i<static_cast<int>(dihits.size()); i++) {
     double ene=dihits[i].hitEnergy();
     double trkfide=dihits[i].hitEnergyTrackFiducial();
     double isolhcale=dihits[i].hcalEnergySameTowers()+dihits[i].hcalEnergyNeighborTowers();
     double isolecale=dihits[i].ecalEnergySameTowers();
     double isoltrke=dihits[i].trackEnergySameTowers()+dihits[i].trackEnergyNeighborTowers();
     if((isolhcale/ene<LooseHcalIsol_ && isolecale/ene<LooseEcalIsol_ && isoltrke/ene<LooseTrackIsol_ && trkfide>0.99*ene && trkfide>LooseDiHitEne_) ||
        (isolhcale/ene<TightHcalIsol_ && isolecale/ene<TightEcalIsol_ && isoltrke/ene<TightTrackIsol_ && ene>TightDiHitEne_)) {
       for(HBHEHitMap::hitmap_const_iterator it=dihits[i].beginHits(); it!=dihits[i].endHits(); ++it)
     noisehits.insert(it->first);
       //      result=false;
     }
   }
   
   for(int i=0; i<static_cast<int>(monohits.size()); i++) {
     double ene=monohits[i].hitEnergy();
     double trkfide=monohits[i].hitEnergyTrackFiducial();
     double isolhcale=monohits[i].hcalEnergySameTowers()+monohits[i].hcalEnergyNeighborTowers();
     double isolecale=monohits[i].ecalEnergySameTowers();
     double isoltrke=monohits[i].trackEnergySameTowers()+monohits[i].trackEnergyNeighborTowers();
     if((isolhcale/ene<LooseHcalIsol_ && isolecale/ene<LooseEcalIsol_ && isoltrke/ene<LooseTrackIsol_ && trkfide>0.99*ene && trkfide>LooseMonoHitEne_) ||
        (isolhcale/ene<TightHcalIsol_ && isolecale/ene<TightEcalIsol_ && isoltrke/ene<TightTrackIsol_ && ene>TightMonoHitEne_)) {
       for(HBHEHitMap::hitmap_const_iterator it=monohits[i].beginHits(); it!=monohits[i].endHits(); ++it)
     noisehits.insert(it->first);
       //      result=false;
     }
   }
 
   // prepare the output HBHE RecHit collection
   std::auto_ptr<HBHERecHitCollection> pOut(new HBHERecHitCollection());
   // loop over rechits, and set the new bit you wish to use
   for(HBHERecHitCollection::const_iterator it=hbhehits_h->begin(); it!=hbhehits_h->end(); ++it) {
     const HBHERecHit* hit=&(*it);
     HBHERecHit newhit(*hit);
     if(noisehits.end()!=noisehits.find(hit)) {
       newhit.setFlagField(1, HcalCaloFlagLabels::HBHEIsolatedNoise);
     }
     pOut->push_back(newhit);
   }
 
   iEvent.put(pOut);
 
   return;  
 }