EcalDeadCellBoundaryEnergyFilter Class Reference

#include <PhysicsTools/EcalDeadCellBoundaryEnergyFilter/src/EcalDeadCellBoundaryEnergyFilter.cc>

Inheritance diagram for EcalDeadCellBoundaryEnergyFilter:

Public Member Functions
	EcalDeadCellBoundaryEnergyFilter (const edm::ParameterSet &)
	~EcalDeadCellBoundaryEnergyFilter () override
Public Member Functions inherited from edm::global::EDFilter<>
	EDFilter ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsStreamLuminosityBlocks () const final
bool	wantsStreamRuns () const final
Public Member Functions inherited from edm::global::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	beginJob () override
void	endJob () override
bool	filter (edm::StreamID, edm::Event &, const edm::EventSetup &) const override

Private Attributes
const double	cutBoundEnergyDeadCellsEB
const double	cutBoundEnergyDeadCellsEE
const double	cutBoundEnergyGapEB
const double	cutBoundEnergyGapEE
const bool	debug_
EcalBoundaryInfoCalculator< EBDetId >	ebBoundaryCalc
edm::EDGetTokenT< EcalRecHitCollection >	EBRecHitsToken_
EcalBoundaryInfoCalculator< EEDetId >	eeBoundaryCalc
edm::EDGetTokenT< EcalRecHitCollection >	EERecHitsToken_
const bool	enableGap_
const std::string	FilterAlgo_
const int	kMAX
const std::vector< int >	limitDeadCellToChannelStatusEB_
const std::vector< int >	limitDeadCellToChannelStatusEE_
const bool	limitFilterToEB_
const bool	limitFilterToEE_
double	maxBoundaryEnergy_
const bool	skimDead_
const bool	skimGap_
const bool	taggingMode_

Additional Inherited Members
Public Types inherited from edm::global::EDFilterBase
typedef EDFilterBase	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::global::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 passive or problematic detector regions. The filter will handle ECAL flags and will compute the boundary energy in the channels surrounding the problematic regions such as dead channels and gaps.

Filter Algos : a) "TuningMode" keep all events and save event info in a ROOT TTree for tuning/algo development b) "FilterMode" returns false for all events passing the AnomalousEcalVariables.isDeadEcalCluster() function (—>rejects events affected by energy deposits in Dead Cells)

Implementation: <Notes on="" implementation>="">

Definition at line 60 of file EcalDeadCellBoundaryEnergyFilter.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 105 of file EcalDeadCellBoundaryEnergyFilter.cc.

References cutBoundEnergyDeadCellsEB, debug_, ebBoundaryCalc, eeBoundaryCalc, maxBoundaryEnergy_, EcalBoundaryInfoCalculator< EcalDetId >::setDebugMode(), skimDead_, and skimGap_.

   : kMAX (50)
   //now do what ever initialization is needed
   , EBRecHitsToken_ (consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag> ("recHitsEB")))
   , EERecHitsToken_ (consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag> ("recHitsEE")))

   , FilterAlgo_ (iConfig.getUntrackedParameter<std::string> ("FilterAlgo", "TuningMode"))
   , taggingMode_ (iConfig.getParameter<bool>("taggingMode"))
   , skimGap_ (iConfig.getUntrackedParameter<bool> ("skimGap", false))
   , skimDead_ (iConfig.getUntrackedParameter<bool> ("skimDead", false))
   , cutBoundEnergyGapEE (iConfig.getUntrackedParameter<double> ("cutBoundEnergyGapEE"))
   , cutBoundEnergyGapEB (iConfig.getUntrackedParameter<double> ("cutBoundEnergyGapEB"))
   , cutBoundEnergyDeadCellsEB (iConfig.getUntrackedParameter<double> ("cutBoundEnergyDeadCellsEB"))
   , cutBoundEnergyDeadCellsEE (iConfig.getUntrackedParameter<double> ("cutBoundEnergyDeadCellsEE"))

   , limitFilterToEB_ (iConfig.getUntrackedParameter<bool> ("limitFilterToEB", false))
   , limitFilterToEE_ (iConfig.getUntrackedParameter<bool> ("limitFilterToEE", false))
   , limitDeadCellToChannelStatusEB_ (iConfig.getParameter<std::vector<int> > ("limitDeadCellToChannelStatusEB"))
   , limitDeadCellToChannelStatusEE_ (iConfig.getParameter<std::vector<int> > ("limitDeadCellToChannelStatusEE"))

   , enableGap_ (iConfig.getUntrackedParameter<bool> ("enableGap", false))
   , debug_ (iConfig.getParameter<bool>("debug"))
{

   maxBoundaryEnergy_ = cutBoundEnergyDeadCellsEB;

   if (skimGap_ && debug_ ) edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "Skim Gap!";
   if (skimDead_ && debug_ ) edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "Skim Dead!";

   if( debug_ ) {
      edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "Constructor EcalAnomalousEvent";
      ebBoundaryCalc.setDebugMode();
      eeBoundaryCalc.setDebugMode();
   }

   produces<bool>();

   produces<AnomalousECALVariables> ("anomalousECALVariables");
}

EcalDeadCellBoundaryEnergyFilter::~EcalDeadCellBoundaryEnergyFilter ( )

override

Definition at line 145 of file EcalDeadCellBoundaryEnergyFilter.cc.

                                                                    {
}

Member Function Documentation

void EcalDeadCellBoundaryEnergyFilter::beginJob ( void  )

overrideprivatevirtual

Reimplemented from edm::global::EDFilterBase.

Definition at line 438 of file EcalDeadCellBoundaryEnergyFilter.cc.

                                                {
}

void EcalDeadCellBoundaryEnergyFilter::endJob ( void  )

overrideprivatevirtual

Reimplemented from edm::global::EDFilterBase.

Definition at line 442 of file EcalDeadCellBoundaryEnergyFilter.cc.

References DEFINE_FWK_MODULE.

                                              {
}

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

overrideprivate

Definition at line 149 of file EcalDeadCellBoundaryEnergyFilter.cc.

References funct::abs(), edm::SortedCollection< T, SORT >::begin(), BoundaryInformation::boundaryEnergy, BoundaryInformation::boundaryET, EcalBoundaryInfoCalculator< EcalDetId >::boundaryRecHits(), EcalBoundaryInfoCalculator< EcalDetId >::checkRecHitHasDeadNeighbour(), EcalBoundaryInfoCalculator< EcalDetId >::checkRecHitHasInvalidNeighbour(), fwrapper::cs, cutBoundEnergyDeadCellsEB, cutBoundEnergyDeadCellsEE, cutBoundEnergyGapEB, cutBoundEnergyGapEE, debug_, BoundaryInformation::detIds, ebBoundaryCalc, egHLT::errCodes::EBRecHits, EBRecHitsToken_, eeBoundaryCalc, egHLT::errCodes::EERecHits, EERecHitsToken_, enableGap_, EcalCondObjectContainer< T >::end(), edm::SortedCollection< T, SORT >::end(), PVValHelper::eta, EcalCondObjectContainer< T >::find(), EcalBoundaryInfoCalculator< EcalDetId >::gapRecHits(), geometry, edm::EventSetup::get(), edm::Event::getByToken(), CaloSubdetectorGeometry::getGeometry(), CaloGeometry::getSubdetectorGeometry(), hit::id, createfilelist::int, limitDeadCellToChannelStatusEB_, limitDeadCellToChannelStatusEE_, limitFilterToEB_, limitFilterToEE_, maxBoundaryEnergy_, eostools::move(), edm::Event::put(), skimDead_, skimGap_, mps_update::status, and taggingMode_.

                                                                                                              {
   using namespace edm;

   //int eventno = (int) iEvent.eventAuxiliary().event();

   std::vector<BoundaryInformation> v_enNeighboursGap_EB;
   std::vector<BoundaryInformation> v_enNeighboursGap_EE;
   v_enNeighboursGap_EB.reserve(50);
   v_enNeighboursGap_EE.reserve(50);

   std::vector<BoundaryInformation> v_boundaryInfoDeadCells_EB;
   std::vector<BoundaryInformation> v_boundaryInfoDeadCells_EE;
   v_boundaryInfoDeadCells_EB.reserve(50);
   v_boundaryInfoDeadCells_EE.reserve(50);

   // Get the Ecal RecHits
   Handle<EcalRecHitCollection> EBRecHits;
   iEvent.getByToken(EBRecHitsToken_, EBRecHits);
   Handle<EcalRecHitCollection> EERecHits;
   iEvent.getByToken(EERecHitsToken_, EERecHits);

   edm::ESHandle<CaloTopology> theCaloTopology;
   iSetup.get<CaloTopologyRecord> ().get(theCaloTopology);

   edm::ESHandle<EcalChannelStatus> ecalStatus;
   iSetup.get<EcalChannelStatusRcd> ().get(ecalStatus);

   edm::ESHandle<CaloGeometry> geometry;
   iSetup.get<CaloGeometryRecord> ().get(geometry);

//   int DeadChannelsCounterEB = 0;
//   int DeadChannelsCounterEE = 0;

   int i_EBDead = 0;
   int i_EEDead = 0;
   int i_EBGap = 0;
   int i_EEGap = 0;

   std::vector<DetId> sameFlagDetIds;

   bool pass = true;

   if (!limitFilterToEE_) {

      if (debug_)
         edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "process EB";

      for (EcalRecHitCollection::const_iterator hit = EBRecHits->begin(); hit != EBRecHits->end(); ++hit) {

         bool detIdAlreadyChecked = false;
         DetId currDetId = (DetId) hit->id();
         //add limitation to channel stati
         EcalChannelStatus::const_iterator chit = ecalStatus->find(currDetId);
         int status = (chit != ecalStatus->end()) ? chit->getStatusCode() & 0x1F : -1;
         if (status != 0)
            continue;
         bool passChannelLimitation = false;

         // check if hit has a dead neighbour
         std::vector<int> deadNeighbourStati;
         ebBoundaryCalc.checkRecHitHasDeadNeighbour(*hit, ecalStatus, deadNeighbourStati);

         for (int cs = 0; cs < (int) limitDeadCellToChannelStatusEB_.size(); ++cs) {
            int channelAllowed = limitDeadCellToChannelStatusEB_[cs];

            for (std::vector<int>::iterator sit = deadNeighbourStati.begin(); sit != deadNeighbourStati.end(); ++sit) {
               if (channelAllowed == *sit || (channelAllowed < 0 && std::abs(channelAllowed) <= *sit)) {
                  passChannelLimitation = true;
                  break;
               }
            }
         }

         for (std::vector<DetId>::iterator it = sameFlagDetIds.begin(); it != sameFlagDetIds.end(); it++) {
            if (currDetId == *it)
               detIdAlreadyChecked = true;
         }

         // RecHit is at EB boundary and should be processed
         if (!detIdAlreadyChecked && deadNeighbourStati.empty() && ebBoundaryCalc.checkRecHitHasInvalidNeighbour(
               *hit, ecalStatus)) {

            BoundaryInformation gapinfo = ebBoundaryCalc.gapRecHits(
                  (const edm::Handle<EcalRecHitCollection>&) EBRecHits, (const EcalRecHit *) &(*hit), theCaloTopology,
                  ecalStatus, geometry);

            // get rechits along gap cluster
            for (std::vector<DetId>::iterator it = gapinfo.detIds.begin(); it != gapinfo.detIds.end(); it++) {
               sameFlagDetIds.push_back(*it);
            }

            if (gapinfo.boundaryEnergy > cutBoundEnergyGapEB) {

               i_EBGap++;
               v_enNeighboursGap_EB.push_back(gapinfo);

               if (debug_)
                  edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "EB: gap cluster energy: " << gapinfo.boundaryEnergy << " deadCells: "
                        << gapinfo.detIds.size();
            }
         }

         // RecHit is member of boundary and should be processed
         if (!detIdAlreadyChecked && (passChannelLimitation || (limitDeadCellToChannelStatusEB_.empty()
               && !deadNeighbourStati.empty()))) {

            BoundaryInformation boundinfo = ebBoundaryCalc.boundaryRecHits(
                  (const edm::Handle<EcalRecHitCollection>&) EBRecHits, (const EcalRecHit *) &(*hit), theCaloTopology,
                  ecalStatus, geometry);

            // get boundary of !kDead rechits arround the dead cluster
            for (std::vector<DetId>::iterator it = boundinfo.detIds.begin(); it != boundinfo.detIds.end(); it++) {
               sameFlagDetIds.push_back(*it);
            }

            if (boundinfo.boundaryEnergy > cutBoundEnergyDeadCellsEB) {

               i_EBDead++;
               v_boundaryInfoDeadCells_EB.push_back(boundinfo);

               if (debug_)
                  edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "EB: boundary Energy dead RecHit: " << boundinfo.boundaryEnergy << " ET: "
                        << boundinfo.boundaryET << " deadCells: " << boundinfo.detIds.size();
            }

         }
      }

   } 

   sameFlagDetIds.clear();

   if (!limitFilterToEB_) {

      if (debug_)
         edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "process EE";

      for (EcalRecHitCollection::const_iterator hit = EERecHits->begin(); hit != EERecHits->end(); ++hit) {

         bool detIdAlreadyChecked = false;
         DetId currDetId = (DetId) hit->id();
         //add limitation to channel stati
         EcalChannelStatus::const_iterator chit = ecalStatus->find(currDetId);
         int status = (chit != ecalStatus->end()) ? chit->getStatusCode() & 0x1F : -1;
         if (status != 0)
            continue;
         bool passChannelLimitation = false;

         // check if hit has a dead neighbour
         std::vector<int> deadNeighbourStati;
         eeBoundaryCalc.checkRecHitHasDeadNeighbour(*hit, ecalStatus, deadNeighbourStati);

         for (int cs = 0; cs < (int) limitDeadCellToChannelStatusEE_.size(); ++cs) {
            int channelAllowed = limitDeadCellToChannelStatusEE_[cs];

            for (std::vector<int>::iterator sit = deadNeighbourStati.begin(); sit != deadNeighbourStati.end(); ++sit) {
               if (channelAllowed == *sit || (channelAllowed < 0 && std::abs(channelAllowed) <= *sit)) {
                  passChannelLimitation = true;
                  break;
               }
            }
         }

         for (std::vector<DetId>::iterator it = sameFlagDetIds.begin(); it != sameFlagDetIds.end(); it++) {
            if (currDetId == *it)
               detIdAlreadyChecked = true;
         }

         // RecHit is at EE boundary and should be processed
         const CaloSubdetectorGeometry* subGeom = geometry->getSubdetectorGeometry(currDetId);
         auto cellGeom = subGeom->getGeometry(currDetId);
         double eta = cellGeom->getPosition().eta();

         if (!detIdAlreadyChecked && deadNeighbourStati.empty() && eeBoundaryCalc.checkRecHitHasInvalidNeighbour(
               *hit, ecalStatus) && std::abs(eta) < 1.6) {

            BoundaryInformation gapinfo = eeBoundaryCalc.gapRecHits(
                  (const edm::Handle<EcalRecHitCollection>&) EERecHits, (const EcalRecHit *) &(*hit), theCaloTopology,
                  ecalStatus, geometry);

            // get rechits along gap cluster
            for (std::vector<DetId>::iterator it = gapinfo.detIds.begin(); it != gapinfo.detIds.end(); it++) {
               sameFlagDetIds.push_back(*it);
            }

            if (gapinfo.boundaryEnergy > cutBoundEnergyGapEE) {

               i_EEGap++;
               v_enNeighboursGap_EE.push_back(gapinfo);

               if (debug_)
                  edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "EE: gap cluster energy: " << gapinfo.boundaryEnergy << " deadCells: "
                        << gapinfo.detIds.size();
            }
         }

         // RecHit is member of boundary and should be processed
         if (!detIdAlreadyChecked && (passChannelLimitation || (limitDeadCellToChannelStatusEE_.empty()
               && !deadNeighbourStati.empty()))) {

            BoundaryInformation boundinfo = eeBoundaryCalc.boundaryRecHits(
                  (const edm::Handle<EcalRecHitCollection>&) EERecHits, (const EcalRecHit *) &(*hit), theCaloTopology,
                  ecalStatus, geometry);

            // get boundary of !kDead rechits arround the dead cluster
            for (std::vector<DetId>::iterator it = boundinfo.detIds.begin(); it != boundinfo.detIds.end(); it++) {
               sameFlagDetIds.push_back(*it);
            }

            if (boundinfo.boundaryEnergy > cutBoundEnergyDeadCellsEE) {

               i_EEDead++;
               v_boundaryInfoDeadCells_EE.push_back(boundinfo);

               if (debug_)
                  edm::LogInfo("EcalDeadCellBoundaryEnergyFilter") << "EE: boundary Energy dead RecHit: " << boundinfo.boundaryEnergy << " ET: "
                        << boundinfo.boundaryET << " deadCells: " << boundinfo.detIds.size();

            }

         }
      }

   } 

   sameFlagDetIds.clear();

   auto pAnomalousECALVariables = std::make_unique<AnomalousECALVariables>(v_enNeighboursGap_EB,
            v_enNeighboursGap_EE, v_boundaryInfoDeadCells_EB, v_boundaryInfoDeadCells_EE);


   bool isGap = pAnomalousECALVariables->isGapEcalCluster(cutBoundEnergyGapEB, cutBoundEnergyGapEE);
   bool isBoundary = pAnomalousECALVariables->isDeadEcalCluster(maxBoundaryEnergy_, limitDeadCellToChannelStatusEB_,
            limitDeadCellToChannelStatusEE_);
   pass = (!isBoundary && ((!isGap && enableGap_) || !enableGap_));

   iEvent.put(std::move(pAnomalousECALVariables), "anomalousECALVariables");

   iEvent.put(std::make_unique<bool>(pass));

   if( taggingMode_ ){
      if (skimDead_ && (i_EBDead >= 1 || i_EEDead >= 1)) {
         return true;
      } else if (skimGap_ && (i_EBGap >= 1 || i_EEGap >= 1)) {
         return true;
      } else if (!skimDead_ && !skimGap_)
         return true;
      else {
         return false;
      }
   }
   else return pass;

/*
   if (FilterAlgo_ == "TuningMode") {
      std::unique_ptr<AnomalousECALVariables> pAnomalousECALVariables(new AnomalousECALVariables(v_enNeighboursGap_EB,
            v_enNeighboursGap_EE, v_boundaryInfoDeadCells_EB, v_boundaryInfoDeadCells_EE));
      iEvent.put(std::move(pAnomalousECALVariables), "anomalousECALVariables");

      if (skimDead_ && (i_EBDead >= 1 || i_EEDead >= 1)) {
         return true;
      } else if (skimGap_ && (i_EBGap >= 1 || i_EEGap >= 1)) {
         return true;
      } else if (!skimDead_ && !skimGap_)
         return true;
      else {
         return false;
      }
   }

   if (FilterAlgo_ == "FilterMode") {
      std::unique_ptr<AnomalousECALVariables> pAnomalousECALVariables(new AnomalousECALVariables(v_enNeighboursGap_EB,
            v_enNeighboursGap_EE, v_boundaryInfoDeadCells_EB, v_boundaryInfoDeadCells_EE));

      bool isGap = pAnomalousECALVariables->isGapEcalCluster(cutBoundEnergyGapEB, cutBoundEnergyGapEE);
      bool isBoundary = pAnomalousECALVariables->isDeadEcalCluster(maxBoundaryEnergy_, limitDeadCellToChannelStatusEB_,
            limitDeadCellToChannelStatusEE_);

      bool result = (!isBoundary && ((!isGap && enableGap_) || !enableGap_));
      if (!result) {
      }
      return result;
   }
*/

//   return true;
}

Member Data Documentation

const double EcalDeadCellBoundaryEnergyFilter::cutBoundEnergyDeadCellsEB

private

Definition at line 82 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by EcalDeadCellBoundaryEnergyFilter(), and filter().

const double EcalDeadCellBoundaryEnergyFilter::cutBoundEnergyDeadCellsEE

private

Definition at line 82 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

const double EcalDeadCellBoundaryEnergyFilter::cutBoundEnergyGapEB

private

Definition at line 82 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

const double EcalDeadCellBoundaryEnergyFilter::cutBoundEnergyGapEE

private

Definition at line 82 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

const bool EcalDeadCellBoundaryEnergyFilter::debug_

private

Definition at line 94 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by EcalDeadCellBoundaryEnergyFilter(), and filter().

EcalBoundaryInfoCalculator<EBDetId> EcalDeadCellBoundaryEnergyFilter::ebBoundaryCalc

private

Definition at line 84 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by EcalDeadCellBoundaryEnergyFilter(), and filter().

edm::EDGetTokenT<EcalRecHitCollection> EcalDeadCellBoundaryEnergyFilter::EBRecHitsToken_

private

Definition at line 73 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

EcalBoundaryInfoCalculator<EEDetId> EcalDeadCellBoundaryEnergyFilter::eeBoundaryCalc

private

Definition at line 85 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by EcalDeadCellBoundaryEnergyFilter(), and filter().

edm::EDGetTokenT<EcalRecHitCollection> EcalDeadCellBoundaryEnergyFilter::EERecHitsToken_

private

Definition at line 74 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

const bool EcalDeadCellBoundaryEnergyFilter::enableGap_

private

Definition at line 93 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

const std::string EcalDeadCellBoundaryEnergyFilter::FilterAlgo_

private

Definition at line 76 of file EcalDeadCellBoundaryEnergyFilter.cc.

const int EcalDeadCellBoundaryEnergyFilter::kMAX

private

Definition at line 71 of file EcalDeadCellBoundaryEnergyFilter.cc.

const std::vector<int> EcalDeadCellBoundaryEnergyFilter::limitDeadCellToChannelStatusEB_

private

Definition at line 90 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

const std::vector<int> EcalDeadCellBoundaryEnergyFilter::limitDeadCellToChannelStatusEE_

private

Definition at line 91 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

const bool EcalDeadCellBoundaryEnergyFilter::limitFilterToEB_

private

Definition at line 89 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

const bool EcalDeadCellBoundaryEnergyFilter::limitFilterToEE_

private

Definition at line 89 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().

double EcalDeadCellBoundaryEnergyFilter::maxBoundaryEnergy_

private

Definition at line 87 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by EcalDeadCellBoundaryEnergyFilter(), and filter().

const bool EcalDeadCellBoundaryEnergyFilter::skimDead_

private

Definition at line 80 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by EcalDeadCellBoundaryEnergyFilter(), and filter().

const bool EcalDeadCellBoundaryEnergyFilter::skimGap_

private

Definition at line 79 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by EcalDeadCellBoundaryEnergyFilter(), and filter().

const bool EcalDeadCellBoundaryEnergyFilter::taggingMode_

private

Definition at line 77 of file EcalDeadCellBoundaryEnergyFilter.cc.

Referenced by filter().