#include <EcalDeadCellTriggerPrimitiveFilter.cc>

Inheritance diagram for EcalDeadCellTriggerPrimitiveFilter:

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

	~EcalDeadCellTriggerPrimitiveFilter () override

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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

ModuleDescription const &	moduleDescription () const

	~EDFilterBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginRun (const edm::Run &, const edm::EventSetup &) override

void	beginStream (edm::StreamID) override

void	envSet (const edm::EventSetup &)

bool	filter (edm::Event &, const edm::EventSetup &) override

int	getChannelStatusMaps ()

void	loadEcalDigis (edm::Event &iEvent, edm::Handle< EcalTrigPrimDigiCollection > &pTPDigis)

void	loadEcalRecHits (edm::Event &iEvent, edm::Handle< EcalRecHitCollection > &barrelReducedRecHitsHandle, edm::Handle< EcalRecHitCollection > &endcapReducedRecHitsHandle)

int	setEvtRecHitstatus (const double &tpValCut, const int &chnStatus, const int &towerTest, const EBRecHitCollection &HitecalEB, const EERecHitCollection &HitecalEE)

int	setEvtTPstatus (const EcalTrigPrimDigiCollection &, const double &tpCntCut, const int &chnStatus, EcalTPGScale &)

Private Attributes
std::map< EcalScDetId, int >	accuSCchnMap

std::map< EcalScDetId, double >	accuSCetMap

std::map< EcalTrigTowerDetId, int >	accuTTchnMap

std::map< EcalTrigTowerDetId, double >	accuTTetMap

std::vector< DetId >	avoidDuplicateVec

const bool	debug_

const bool	doEEfilter_

const edm::InputTag	ebReducedRecHitCollection_

edm::EDGetTokenT< EcalRecHitCollection >	ebReducedRecHitCollectionToken_

std::map< DetId, std::vector< int > >	EcalAllDeadChannelsBitMap

std::map< DetId, EcalTrigTowerDetId >	EcalAllDeadChannelsTTMap

std::map< DetId, std::vector< double > >	EcalAllDeadChannelsValMap

edm::ESHandle< EcalChannelStatus >	ecalStatus

const edm::InputTag	eeReducedRecHitCollection_

edm::EDGetTokenT< EcalRecHitCollection >	eeReducedRecHitCollectionToken_

const double	etValToBeFlagged_

edm::ESHandle< CaloGeometry >	geometry

int	hasReducedRecHits_ = 0

const int	maskedEcalChannelStatusThreshold_

edm::EDPutTokenT< bool >	putToken_

std::map< EcalScDetId, int >	SCzsideMap

const bool	taggingMode_

const edm::InputTag	tpDigiCollection_

edm::EDGetTokenT< EcalTrigPrimDigiCollection >	tpDigiCollectionToken_

edm::ESHandle< EcalTrigTowerConstituentsMap >	ttMap_

std::map< EcalTrigTowerDetId, int >	TTzsideMap

bool	useHITmethod_ = false

const bool	usekTPSaturated_

bool	useTPmethod_ = false

const bool	useTTsum_

const int	verbose_

Additional Inherited Members
Public Types inherited from edm::stream::EDFilter<>
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::EDFilterBase
typedef EDFilterAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDFilterBase
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

Description: <one line="" class="" summary>=""> Event filtering for anomalous ECAL events where the energy measured by ECAL is significantly biased due to energy depositions in dead cell regions.

Definition at line 72 of file EcalDeadCellTriggerPrimitiveFilter.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 165 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References edm::ProducerBase::callWhenNewProductsRegistered(), ebReducedRecHitCollection_, ebReducedRecHitCollectionToken_, eeReducedRecHitCollection_, eeReducedRecHitCollectionToken_, hasReducedRecHits_, edm::InputTag::label(), edm::BranchDescription::moduleLabel(), tpDigiCollection_, useHITmethod_, and useTPmethod_.

Referenced by getChannelStatusMaps().

   : taggingMode_ (iConfig.getParameter<bool>("taggingMode") )
   , debug_ (iConfig.getParameter<bool>("debug") )
   , verbose_ (iConfig.getParameter<int>("verbose") )
   , doEEfilter_ (iConfig.getUntrackedParameter<bool>("doEEfilter") )
   , ebReducedRecHitCollection_ (iConfig.getParameter<edm::InputTag>("ebReducedRecHitCollection") )
   , eeReducedRecHitCollection_ (iConfig.getParameter<edm::InputTag>("eeReducedRecHitCollection") )
   , maskedEcalChannelStatusThreshold_ (iConfig.getParameter<int>("maskedEcalChannelStatusThreshold") )
   , etValToBeFlagged_ (iConfig.getParameter<double>("etValToBeFlagged") )
   , tpDigiCollection_ (iConfig.getParameter<edm::InputTag>("tpDigiCollection") )
   , tpDigiCollectionToken_(consumes<EcalTrigPrimDigiCollection>(tpDigiCollection_))
   , useTTsum_ (iConfig.getParameter<bool>("useTTsum") )
   , usekTPSaturated_ (iConfig.getParameter<bool>("usekTPSaturated") )
   , putToken_ ( produces<bool>() )
 {
   callWhenNewProductsRegistered([this](edm::BranchDescription const& iBranch) {
     // If TP is available, always use TP.
     // In RECO file, we always have ecalTPSkim (at least from 38X for data and 39X for MC).
     // In AOD file, we can only have recovered rechits in the reduced rechits collection after 42X
     // Do NOT expect end-users provide ecalTPSkim or recovered rechits themselves!!
     // If they really can provide them, they must be experts to modify this code to suit their own purpose :-)
     if( iBranch.moduleLabel() ==  tpDigiCollection_.label() ){ 
       useTPmethod_ = true;
       //if both collections are in the job then we may already have seen the reduced collections
       useHITmethod_ = false;
     }
     if( iBranch.moduleLabel() == ebReducedRecHitCollection_.label() || iBranch.moduleLabel() == eeReducedRecHitCollection_.label() ){
        hasReducedRecHits_++;
        if(not useTPmethod_ && hasReducedRecHits_ == 2) {
          useHITmethod_ = true;
          ebReducedRecHitCollectionToken_ = consumes<EcalRecHitCollection>(ebReducedRecHitCollection_);
          eeReducedRecHitCollectionToken_ = consumes<EcalRecHitCollection>(eeReducedRecHitCollection_);
        }
     }
     });
 }

EcalDeadCellTriggerPrimitiveFilter::~EcalDeadCellTriggerPrimitiveFilter ( )

override

Definition at line 202 of file EcalDeadCellTriggerPrimitiveFilter.cc.

202 {

203 }

Member Function Documentation

void EcalDeadCellTriggerPrimitiveFilter::beginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 297 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References debug_, EcalAllDeadChannelsBitMap, EcalAllDeadChannelsValMap, envSet(), getChannelStatusMaps(), mathSSE::return(), and verbose_.

                                                                                                  {
 // Channel status might change for each run (data)
 // Event setup
   envSet(iSetup);
   getChannelStatusMaps();
   if( debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<< "EcalAllDeadChannelsValMap.size() : "<<EcalAllDeadChannelsValMap.size()<<"  EcalAllDeadChannelsBitMap.size() : "<<EcalAllDeadChannelsBitMap.size();
   return ;
 }

void EcalDeadCellTriggerPrimitiveFilter::beginStream ( edm::StreamID )

overrideprivatevirtual

Reimplemented from edm::stream::EDFilterBase.

Definition at line 205 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References debug_, hasReducedRecHits_, useHITmethod_, and useTPmethod_.

                                                                {
 
   if( debug_ ) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"\nuseTPmethod_ : "<<useTPmethod_<<"  hasReducedRecHits_ : "<<hasReducedRecHits_;
 
   if( not useTPmethod_ and not useHITmethod_){ 
     if( debug_ ){
       edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"\nWARNING ... Cannot find either tpDigiCollection_ or reducedRecHitCollecion_ ?!";
       edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"  Will NOT DO ANY FILTERING !";
     }
   }
 
   if( debug_ ) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"useTPmethod_ : "<<useTPmethod_<<"  useHITmethod_ : "<<useHITmethod_;
 
 }

void EcalDeadCellTriggerPrimitiveFilter::envSet ( const edm::EventSetup & iSetup )

private

Definition at line 241 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References debug_, ecalStatus, edm::EventSetup::get(), ttMap_, and verbose_.

Referenced by beginRun().

                                                                            {
 
   if (debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter") << "***envSet***";
 
   iSetup.get<IdealGeometryRecord>().get(ttMap_);
 
   iSetup.get<EcalChannelStatusRcd> ().get(ecalStatus);
   iSetup.get<CaloGeometryRecord>   ().get(geometry);
 
   if( !ecalStatus.isValid() )  throw "Failed to get ECAL channel status!";
   if( !geometry.isValid()   )  throw "Failed to get the geometry!";
 
 }

bool EcalDeadCellTriggerPrimitiveFilter::filter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 256 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References funct::abs(), debug_, edm::Event::emplace(), etValToBeFlagged_, edm::EventID::event(), edm::EventBase::id(), loadEcalDigis(), loadEcalRecHits(), eostools::ls(), edm::EventBase::luminosityBlock(), putToken_, writedatasetfile::run, edm::EventID::run(), EcalTPGScale::setEventSetup(), setEvtRecHitstatus(), setEvtTPstatus(), taggingMode_, useHITmethod_, useTPmethod_, and verbose_.

                                                                                              {
 
   edm::RunNumber_t run = iEvent.id().run();
   edm::EventNumber_t event = iEvent.id().event();
   edm::LuminosityBlockNumber_t ls = iEvent.luminosityBlock();
 
   bool pass = true;
 
   int evtTagged = 0;
 
 
   if( useTPmethod_ ){
      edm::Handle<EcalTrigPrimDigiCollection> pTPDigis;
      loadEcalDigis(iEvent, pTPDigis);
 
      EcalTPGScale ecalScale;
      ecalScale.setEventSetup(iSetup);
      evtTagged = setEvtTPstatus(*pTPDigis, etValToBeFlagged_, 13, ecalScale);
   }
 
   if( useHITmethod_ ){
      edm::Handle<EcalRecHitCollection> barrelReducedRecHitsHandle;
      edm::Handle<EcalRecHitCollection> endcapReducedRecHitsHandle;
      loadEcalRecHits(iEvent, barrelReducedRecHitsHandle, endcapReducedRecHitsHandle);
      evtTagged = setEvtRecHitstatus(etValToBeFlagged_, 13, 13, *barrelReducedRecHitsHandle, *endcapReducedRecHitsHandle);
   }
 
   if( evtTagged ){ pass = false; }
 
   if(debug_ && verbose_ >=2){
      int evtstatusABS = abs(evtTagged);
      printf("\nrun : %8u  event : %10llu  lumi : %4u  evtTPstatus  ABS : %d  13 : % 2d\n", run, event, ls, evtstatusABS, evtTagged);
   }
 
   iEvent.emplace(putToken_, pass);
 
   if (taggingMode_) return true;
   else return pass;
 }

int EcalDeadCellTriggerPrimitiveFilter::getChannelStatusMaps ( )

private

Definition at line 549 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References DEFINE_FWK_MODULE, doEEfilter_, EcalAllDeadChannelsBitMap, EcalAllDeadChannelsTTMap, EcalAllDeadChannelsValMap, EcalDeadCellTriggerPrimitiveFilter(), ecalStatus, PVValHelper::eta, EBDetId::ETAPHIMODE, CaloSubdetectorGeometry::getGeometry(), maskedEcalChannelStatusThreshold_, phi, mps_update::status, theta(), EcalTrigTowerConstituentsMap::towerOf(), ttMap_, EBDetId::validDetId(), EEDetId::validDetId(), and EEDetId::XYMODE.

Referenced by beginRun().

                                                             {
 
   EcalAllDeadChannelsValMap.clear(); EcalAllDeadChannelsBitMap.clear();
 
 // Loop over EB ...
   for( int ieta=-85; ieta<=85; ieta++ ){
      for( int iphi=0; iphi<=360; iphi++ ){
         if(! EBDetId::validDetId( ieta, iphi ) )  continue;
 
         const EBDetId detid = EBDetId( ieta, iphi, EBDetId::ETAPHIMODE );
         EcalChannelStatus::const_iterator chit = ecalStatus->find( detid );
 // refer https://twiki.cern.ch/twiki/bin/viewauth/CMS/EcalChannelStatus
         int status = ( chit != ecalStatus->end() ) ? chit->getStatusCode() & 0x1F : -1;
 
     const CaloSubdetectorGeometry* subGeom = geometry->getSubdetectorGeometry (detid);
         auto cellGeom = subGeom->getGeometry (detid);
         double eta = cellGeom->getPosition ().eta ();
         double phi = cellGeom->getPosition ().phi ();
         double theta = cellGeom->getPosition().theta();
 
         if(status >= maskedEcalChannelStatusThreshold_){
            std::vector<double> valVec; std::vector<int> bitVec;
            valVec.push_back(eta); valVec.push_back(phi); valVec.push_back(theta);
            bitVec.push_back(1); bitVec.push_back(ieta); bitVec.push_back(iphi); bitVec.push_back(status);
            EcalAllDeadChannelsValMap.insert( std::make_pair(detid, valVec) );
            EcalAllDeadChannelsBitMap.insert( std::make_pair(detid, bitVec) );
         }
      } // end loop iphi
   } // end loop ieta
 
 // Loop over EE detid
   if (doEEfilter_) {
       for( int ix=0; ix<=100; ix++ ){
          for( int iy=0; iy<=100; iy++ ){
             for( int iz=-1; iz<=1; iz++ ){
                if(iz==0)  continue;
                if(! EEDetId::validDetId( ix, iy, iz ) )  continue;
 
                const EEDetId detid = EEDetId( ix, iy, iz, EEDetId::XYMODE );
                EcalChannelStatus::const_iterator chit = ecalStatus->find( detid );
                int status = ( chit != ecalStatus->end() ) ? chit->getStatusCode() & 0x1F : -1;
 
                const CaloSubdetectorGeometry* subGeom = geometry->getSubdetectorGeometry (detid);
                auto  cellGeom = subGeom->getGeometry (detid);
                double eta = cellGeom->getPosition ().eta () ;
                double phi = cellGeom->getPosition ().phi () ;
                double theta = cellGeom->getPosition().theta();
 
                if(status >= maskedEcalChannelStatusThreshold_){
                   std::vector<double> valVec; std::vector<int> bitVec;
                   valVec.push_back(eta); valVec.push_back(phi); valVec.push_back(theta);
                   bitVec.push_back(2); bitVec.push_back(ix); bitVec.push_back(iy); bitVec.push_back(iz); bitVec.push_back(status);
                   EcalAllDeadChannelsValMap.insert( std::make_pair(detid, valVec) );
                   EcalAllDeadChannelsBitMap.insert( std::make_pair(detid, bitVec) );
                }
             } // end loop iz
          } // end loop iy
       } // end loop ix
   }
 
   EcalAllDeadChannelsTTMap.clear();
   std::map<DetId, std::vector<int> >::iterator bitItor;
   for(bitItor = EcalAllDeadChannelsBitMap.begin(); bitItor != EcalAllDeadChannelsBitMap.end(); bitItor++){
      const DetId id = bitItor->first;
      EcalTrigTowerDetId ttDetId = ttMap_->towerOf(id);
      EcalAllDeadChannelsTTMap.insert(std::make_pair(id, ttDetId) );
   }
 
   return 1;
 }

void EcalDeadCellTriggerPrimitiveFilter::loadEcalDigis	(	edm::Event &	iEvent,
		edm::Handle< EcalTrigPrimDigiCollection > &	pTPDigis
	)

private

Definition at line 220 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References edm::Event::getByToken(), edm::InputTag::instance(), edm::HandleBase::isValid(), edm::InputTag::label(), tpDigiCollection_, and tpDigiCollectionToken_.

Referenced by filter().

                                                                                                                        {
 
   iEvent.getByToken(tpDigiCollectionToken_, pTPDigis);
   if ( !pTPDigis.isValid() ) { edm::LogWarning("EcalDeadCellTriggerPrimitiveFilter") << "Can't get the product " << tpDigiCollection_.instance()
                                              << " with label " << tpDigiCollection_.label(); return; }
 }

void EcalDeadCellTriggerPrimitiveFilter::loadEcalRecHits	(	edm::Event &	iEvent,
		edm::Handle< EcalRecHitCollection > &	barrelReducedRecHitsHandle,
		edm::Handle< EcalRecHitCollection > &	endcapReducedRecHitsHandle
	)

private

Definition at line 227 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References ebReducedRecHitCollectionToken_, eeReducedRecHitCollectionToken_, and edm::Event::getByToken().

Referenced by filter().

 {
 
   iEvent.getByToken(ebReducedRecHitCollectionToken_,barrelReducedRecHitsHandle);
   iEvent.getByToken(eeReducedRecHitCollectionToken_,endcapReducedRecHitsHandle);
 
 }

int EcalDeadCellTriggerPrimitiveFilter::setEvtRecHitstatus	(	const double &	tpValCut,
		const int &	chnStatus,
		const int &	towerTest,
		const EBRecHitCollection &	HitecalEB,
		const EERecHitCollection &	HitecalEE
	)

private

Definition at line 306 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References funct::abs(), accuSCchnMap, accuSCetMap, accuTTchnMap, accuTTetMap, avoidDuplicateVec, edm::SortedCollection< T, SORT >::begin(), EcalTrigTowerConstituentsMap::constituentsOf(), debug_, EcalAllDeadChannelsBitMap, EcalAllDeadChannelsTTMap, EcalAllDeadChannelsValMap, edm::SortedCollection< T, SORT >::end(), spr::find(), EEDetId::ix(), EEDetId::iy(), EcalRecHit::kTPSaturated, SimDataFormats::CaloAnalysis::sc, SCzsideMap, edm::second(), funct::sin(), mps_update::status, theta(), ttMap_, TTzsideMap, usekTPSaturated_, useTTsum_, verbose_, EcalTrigTowerDetId::zside(), and EEDetId::zside().

Referenced by filter().

                                                             {
 
   if( debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"***begin setEvtTPstatusRecHits***";
 
   accuTTetMap.clear(); accuTTchnMap.clear(); TTzsideMap.clear();
   accuSCetMap.clear(); accuSCchnMap.clear(); SCzsideMap.clear();
   avoidDuplicateVec.clear();
 
 /*
   const EBRecHitCollection HitecalEB = *(barrelRecHitsHandle.product());
   const EERecHitCollection HitecalEE = *(endcapRecHitsHandle.product());
 */
   int isPassCut =0;
 
   EBRecHitCollection::const_iterator ebrechit;
 
   for (ebrechit = HitecalEB.begin(); ebrechit != HitecalEB.end(); ebrechit++) {
 
      EBDetId det = ebrechit->id();
 
      std::map<DetId, vector<double> >::iterator valItor = EcalAllDeadChannelsValMap.find(det);
      if( valItor == EcalAllDeadChannelsValMap.end() ) continue;
 
      double theta = valItor->second.back();
 
      std::map<DetId, vector<int> >::iterator bitItor = EcalAllDeadChannelsBitMap.find(det);
      if( bitItor == EcalAllDeadChannelsBitMap.end() ) continue;
 
      std::map<DetId, EcalTrigTowerDetId>::iterator ttItor = EcalAllDeadChannelsTTMap.find(det);
      if( ttItor == EcalAllDeadChannelsTTMap.end() ) continue;
 
      int status = bitItor->second.back();
 
      bool toDo = false;
      if( chnStatus >0 && status == chnStatus ) toDo = true;
      if( chnStatus <0 && status >= abs(chnStatus) ) toDo = true;
 // This might be suitable for channels with status other than 13,
 // since this function is written as a general one ...
      if( !ebrechit->isRecovered() ) toDo = false;
 //     if( !ebrechit->checkFlag(EcalRecHit::kTowerRecovered) ) toDo = false;
 
 
 
      if( toDo ){
 
     //If we considerkTPSaturated and a recHit has a flag set, we can immediately flag the event.
         if(ebrechit->checkFlag(EcalRecHit::kTPSaturated) && usekTPSaturated_) return 1;
 
         EcalTrigTowerDetId ttDetId = ttItor->second;
         int ttzside = ttDetId.zside();
 
         std::vector<DetId> vid = ttMap_->constituentsOf(ttDetId);
         int towerTestCnt =0;
         for(std::vector<DetId>::const_iterator dit = vid.begin(); dit != vid.end(); ++dit ) {
            std::map<DetId, vector<int> >::iterator bit2Itor = EcalAllDeadChannelsBitMap.find( (*dit) );
            if( bit2Itor == EcalAllDeadChannelsBitMap.end() ){ towerTestCnt ++; continue; }
            if( towerTest >0 && bit2Itor->second.back() == towerTest ) continue;
            if( towerTest <0 && bit2Itor->second.back() >= abs(towerTest) ) continue;
            towerTestCnt ++;
         }
         if( towerTestCnt !=0 && debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"towerTestCnt : "<<towerTestCnt<<"  for towerTest : "<<towerTest;
 
         std::vector<DetId>::iterator avoidItor; avoidItor = find( avoidDuplicateVec.begin(), avoidDuplicateVec.end(), det);
         if( avoidItor == avoidDuplicateVec.end() ){
            avoidDuplicateVec.push_back(det);
         }else{
            continue;
         }
 
         std::map<EcalTrigTowerDetId, double>::iterator ttetItor = accuTTetMap.find(ttDetId);
         if( ttetItor == accuTTetMap.end() ){
            accuTTetMap[ttDetId] = ebrechit->energy()*sin(theta);
            accuTTchnMap[ttDetId] = 1;
            TTzsideMap[ttDetId] = ttzside;
         }else{
            accuTTetMap[ttDetId] += ebrechit->energy()*sin(theta);
            accuTTchnMap[ttDetId] ++;
         }
      }
   } // loop over EB
 
   EERecHitCollection::const_iterator eerechit;
   for (eerechit = HitecalEE.begin(); eerechit != HitecalEE.end(); eerechit++) {
 
      EEDetId det = eerechit->id();
 
      std::map<DetId, vector<double> >::iterator valItor = EcalAllDeadChannelsValMap.find(det);
      if( valItor == EcalAllDeadChannelsValMap.end() ) continue;
 
      double theta = valItor->second.back();
 
      std::map<DetId, vector<int> >::iterator bitItor = EcalAllDeadChannelsBitMap.find(det);
      if( bitItor == EcalAllDeadChannelsBitMap.end() ) continue;
 
      std::map<DetId, EcalTrigTowerDetId>::iterator ttItor = EcalAllDeadChannelsTTMap.find(det);
      if( ttItor == EcalAllDeadChannelsTTMap.end() ) continue;
 
      int status = bitItor->second.back();
 
      bool toDo = false;
      if( chnStatus >0 && status == chnStatus ) toDo = true;
      if( chnStatus <0 && status >= abs(chnStatus) ) toDo = true;
 // This might be suitable for channels with status other than 13,
 // since this function is written as a general one ...
      if( !eerechit->isRecovered() ) toDo = false;
 //     if( !eerechit->checkFlag(EcalRecHit::kTowerRecovered) ) toDo = false;
 
      if( toDo ){
 
     //If we considerkTPSaturated and a recHit has a flag set, we can immediately flag the event.
         if(eerechit->checkFlag(EcalRecHit::kTPSaturated) && usekTPSaturated_) return 1;
 
 // vvvv= Only for debuging or testing purpose =vvvv
         EcalTrigTowerDetId ttDetId = ttItor->second;
 //        int ttzside = ttDetId.zside();
 
         std::vector<DetId> vid = ttMap_->constituentsOf(ttDetId);
         int towerTestCnt =0;
         for(std::vector<DetId>::const_iterator dit = vid.begin(); dit != vid.end(); ++dit ) {
            std::map<DetId, vector<int> >::iterator bit2Itor = EcalAllDeadChannelsBitMap.find( (*dit) );
            if( bit2Itor == EcalAllDeadChannelsBitMap.end() ){ towerTestCnt ++; continue; }
            if( towerTest >0 && bit2Itor->second.back() == towerTest ) continue;
            if( towerTest <0 && bit2Itor->second.back() >= abs(towerTest) ) continue;
            towerTestCnt ++;
         }
         if( towerTestCnt !=0 && debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"towerTestCnt : "<<towerTestCnt<<"  for towerTest : "<<towerTest;
 // ^^^^=                  END                 =^^^^
 
         EcalScDetId sc( (det.ix()-1)/5+1, (det.iy()-1)/5+1, det.zside() );
 
         std::vector<DetId>::iterator avoidItor; avoidItor = find( avoidDuplicateVec.begin(), avoidDuplicateVec.end(), det);
         if( avoidItor == avoidDuplicateVec.end() ){
            avoidDuplicateVec.push_back(det);
         }else{
            continue;
         }
 
         std::map<EcalScDetId, double>::iterator scetItor = accuSCetMap.find(sc);
         if( scetItor == accuSCetMap.end() ){
            accuSCetMap[sc] = eerechit->energy()*sin(theta);
            accuSCchnMap[sc] = 1;
            SCzsideMap[sc] = sc.zside();
         }else{
            accuSCetMap[sc] += eerechit->energy()*sin(theta);
            accuSCchnMap[sc] ++;
         }
      }
   } // loop over EE
 
   //If we are not using the TT sum, then at this point we need not do anything further, we'll pass the event
   if(!useTTsum_) return 0;
 
 // Checking for EB
   std::map<EcalTrigTowerDetId, double>::iterator ttetItor;
   for( ttetItor = accuTTetMap.begin(); ttetItor != accuTTetMap.end(); ttetItor++){
 
      EcalTrigTowerDetId ttDetId = ttetItor->first;
 
      double ttetVal = ttetItor->second;
 
      std::map<EcalTrigTowerDetId, int>::iterator ttchnItor = accuTTchnMap.find(ttDetId);
      if( ttchnItor == accuTTchnMap.end() ){ edm::LogError("EcalDeadCellTriggerPrimitiveFilter")<<"\nERROR  cannot find ttDetId : "<<ttDetId<<" in accuTTchnMap?!"; }
 
      std::map<EcalTrigTowerDetId, int>::iterator ttzsideItor = TTzsideMap.find(ttDetId);
      if( ttzsideItor == TTzsideMap.end() ){ edm::LogError("EcalDeadCellTriggerPrimitiveFilter")<<"\nERROR  cannot find ttDetId : "<<ttDetId<<" in TTzsideMap?!"; }
 
      if( ttchnItor->second != 25 && debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"WARNING ... ttchnCnt : "<<ttchnItor->second<<"  NOT equal  25!";
 
      if( ttetVal >= tpValCut ){ isPassCut = 1; isPassCut *= ttzsideItor->second; }
 
   }
 
 // Checking for EE
   std::map<EcalScDetId, double>::iterator scetItor;
   for( scetItor = accuSCetMap.begin(); scetItor != accuSCetMap.end(); scetItor++){
 
      EcalScDetId scDetId = scetItor->first;
 
      double scetVal = scetItor->second;
 
      std::map<EcalScDetId, int>::iterator scchnItor = accuSCchnMap.find(scDetId);
      if( scchnItor == accuSCchnMap.end() ){ edm::LogError("EcalDeadCellTriggerPrimitiveFilter")<<"\nERROR  cannot find scDetId : "<<scDetId<<" in accuSCchnMap?!"; }
 
      std::map<EcalScDetId, int>::iterator sczsideItor = SCzsideMap.find(scDetId);
      if( sczsideItor == SCzsideMap.end() ){ edm::LogError("EcalDeadCellTriggerPrimitiveFilter")<<"\nERROR  cannot find scDetId : "<<scDetId<<" in SCzsideMap?!"; }
 
      if( scchnItor->second != 25 && debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"WARNING ... scchnCnt : "<<scchnItor->second<<"  NOT equal  25!";
 
      if( scetVal >= tpValCut ){ isPassCut = 1; isPassCut *= sczsideItor->second; }
 
   }
 
   if( debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"***end setEvtTPstatusRecHits***";
 
   return isPassCut;
 
 }

int EcalDeadCellTriggerPrimitiveFilter::setEvtTPstatus	(	const EcalTrigPrimDigiCollection &	,
		const double &	tpCntCut,
		const int &	chnStatus,
		EcalTPGScale &
	)

private

Definition at line 508 of file EcalDeadCellTriggerPrimitiveFilter.cc.

References funct::abs(), debug_, doEEfilter_, EcalAllDeadChannelsBitMap, EcalAllDeadChannelsTTMap, edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), EcalTPGScale::getTPGInGeV(), mps_update::status, verbose_, and EcalTrigTowerDetId::zside().

Referenced by filter().

                                                                                                                                                                        {
 
   if( debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"***begin setEvtTPstatus***";
 
   int isPassCut =0;
 
   std::map<DetId, std::vector<int> >::iterator bitItor;
   for(bitItor = EcalAllDeadChannelsBitMap.begin(); bitItor != EcalAllDeadChannelsBitMap.end(); bitItor++){
 
      DetId maskedDetId = bitItor->first;
      int subdet = bitItor->second.front(), status = bitItor->second.back();
 
 // if NOT filtering on EE, skip EE subdet
      if( !doEEfilter_ && subdet != 1 ) continue;
 
      std::map<DetId, EcalTrigTowerDetId>::iterator ttItor = EcalAllDeadChannelsTTMap.find(maskedDetId);
      if( ttItor == EcalAllDeadChannelsTTMap.end() ) continue;
 
      bool toDo = false;
      if( chnStatus >0 && status == chnStatus ) toDo = true;
      if( chnStatus <0 && status >= abs(chnStatus) ) toDo = true;
 
      if( toDo ){
 
         EcalTrigTowerDetId ttDetId = ttItor->second;
         int ttzside = ttDetId.zside();
 
         EcalTrigPrimDigiCollection::const_iterator tp = tpDigis.find( ttDetId );
         if( tp != tpDigis.end() ){
            double tpEt = ecalScale.getTPGInGeV( tp->compressedEt(), tp->id() );
            if(tpEt >= tpValCut ){ isPassCut = 1; isPassCut *= ttzside; }
         }
      }
   } // loop over EB + EE
 
   if( debug_ && verbose_ >=2) edm::LogInfo("EcalDeadCellTriggerPrimitiveFilter")<<"***end setEvtTPstatus***";
 
   return isPassCut;
 }