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

Inheritance diagram for EcalDeadCellBoundaryEnergyFilter:

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

	~EcalDeadCellBoundaryEnergyFilter ()

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

ModuleDescription const &	moduleDescription () const

virtual	~EDFilter ()

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
virtual void	beginJob () override

virtual void	endJob () override

virtual bool	filter (edm::Event &, const edm::EventSetup &) 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_

float *	enNeighboursGap_EB

float *	enNeighboursGap_EE

const std::string	FilterAlgo_

int	i_EBDead

int	i_EBGap

int	i_EEDead

int	i_EEGap

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_

std::vector< BoundaryInformation >	v_boundaryInfoDeadCells_EB

std::vector< BoundaryInformation >	v_boundaryInfoDeadCells_EE

std::vector< BoundaryInformation >	v_enNeighboursGap_EB

std::vector< BoundaryInformation >	v_enNeighboursGap_EE

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	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::EDFilter
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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

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 115 of file EcalDeadCellBoundaryEnergyFilter.cc.

References gather_cfg::cout, cutBoundEnergyDeadCellsEB, debug_, i_EBDead, i_EBGap, i_EEDead, i_EEGap, maxBoundaryEnergy_, skimDead_, skimGap_, v_boundaryInfoDeadCells_EB, v_boundaryInfoDeadCells_EE, v_enNeighboursGap_EB, and v_enNeighboursGap_EE.

    : 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;
 
    i_EBDead = 0;
    i_EEDead = 0;
    i_EBGap = 0;
    i_EEGap = 0;
 
    v_enNeighboursGap_EB.clear();
    v_enNeighboursGap_EE.clear();
    v_enNeighboursGap_EB.reserve(50);
    v_enNeighboursGap_EE.reserve(50);
 
    v_boundaryInfoDeadCells_EB.reserve(50);
    v_boundaryInfoDeadCells_EE.reserve(50);
    v_boundaryInfoDeadCells_EB.clear();
    v_boundaryInfoDeadCells_EE.clear();
 
    if (skimGap_ && debug_ ) std::cout << "Skim Gap!" << std::endl;
    if (skimDead_ && debug_ ) std::cout << "Skim Dead!" << std::endl;
 
    if( debug_ ) std::cout << "Constructor EcalAnomalousEvent" << std::endl;
 
    produces<bool>();
 
    produces<AnomalousECALVariables> ("anomalousECALVariables");
 }

EcalDeadCellBoundaryEnergyFilter::~EcalDeadCellBoundaryEnergyFilter ( )

Definition at line 166 of file EcalDeadCellBoundaryEnergyFilter.cc.

                                                                     {
    //std::cout << "destructor Filter" << std::endl;
 }

Member Function Documentation

void EcalDeadCellBoundaryEnergyFilter::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDFilter.

Definition at line 470 of file EcalDeadCellBoundaryEnergyFilter.cc.

470 {

471 }

void EcalDeadCellBoundaryEnergyFilter::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDFilter.

Definition at line 474 of file EcalDeadCellBoundaryEnergyFilter.cc.

474 {

475 }

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

overrideprivatevirtual

Implements edm::EDFilter.

Definition at line 171 of file EcalDeadCellBoundaryEnergyFilter.cc.

References funct::abs(), BoundaryInformation::boundaryEnergy, BoundaryInformation::boundaryET, EcalBoundaryInfoCalculator< EcalDetId >::boundaryRecHits(), EcalBoundaryInfoCalculator< EcalDetId >::checkRecHitHasDeadNeighbour(), EcalBoundaryInfoCalculator< EcalDetId >::checkRecHitHasInvalidNeighbour(), gather_cfg::cout, fwrapper::cs, cutBoundEnergyDeadCellsEB, cutBoundEnergyDeadCellsEE, cutBoundEnergyGapEB, cutBoundEnergyGapEE, debug_, BoundaryInformation::detIds, ebBoundaryCalc, egHLT::errCodes::EBRecHits, EBRecHitsToken_, eeBoundaryCalc, egHLT::errCodes::EERecHits, EERecHitsToken_, enableGap_, eta, PV3DBase< T, PVType, FrameType >::eta(), EcalBoundaryInfoCalculator< EcalDetId >::gapRecHits(), geometry, edm::EventSetup::get(), edm::Event::getByToken(), CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), i_EBDead, i_EBGap, i_EEDead, i_EEGap, hit::id, limitDeadCellToChannelStatusEB_, limitDeadCellToChannelStatusEE_, limitFilterToEB_, limitFilterToEE_, maxBoundaryEnergy_, edm::Event::put(), EcalBoundaryInfoCalculator< EcalDetId >::setDebugMode(), skimDead_, skimGap_, ntuplemaker::status, taggingMode_, v_boundaryInfoDeadCells_EB, v_boundaryInfoDeadCells_EE, v_enNeighboursGap_EB, and v_enNeighboursGap_EE.

                                                                                            {
    using namespace edm;
 
    //int eventno = (int) iEvent.eventAuxiliary().event();
 
    v_enNeighboursGap_EB.clear();
    v_enNeighboursGap_EE.clear();
 
    v_boundaryInfoDeadCells_EB.clear();
    v_boundaryInfoDeadCells_EE.clear();
 
    // 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;
 
    i_EBDead = 0;
    i_EEDead = 0;
    i_EBGap = 0;
    i_EEGap = 0;
 
    std::vector<DetId> sameFlagDetIds;
 
    bool pass = true;
 
    if (!limitFilterToEE_) {
 
       if (debug_)
          std::cout << "process EB" << std::endl;
 
       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) {
                //std::cout << "Neighbouring dead channel with status: " << *sit << std::endl;
                if (channelAllowed == *sit || (channelAllowed < 0 && 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.size() == 0 && ebBoundaryCalc.checkRecHitHasInvalidNeighbour(
                *hit, ecalStatus)) {
 
             if (debug_)
                ebBoundaryCalc.setDebugMode();
             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_)
                   std::cout << "EB: gap cluster energy: " << gapinfo.boundaryEnergy << " deadCells: "
                         << gapinfo.detIds.size() << std::endl;
             }
          }
 
          // RecHit is member of boundary and should be processed
          if (!detIdAlreadyChecked && (passChannelLimitation || (limitDeadCellToChannelStatusEB_.size() == 0
                && deadNeighbourStati.size() > 0))) {
 
             if (debug_)
                ebBoundaryCalc.setDebugMode();
             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_)
                   std::cout << "EB: boundary Energy dead RecHit: " << boundinfo.boundaryEnergy << " ET: "
                         << boundinfo.boundaryET << " deadCells: " << boundinfo.detIds.size() << std::endl;
             }
 
          }
       }
 
    } 
 
    sameFlagDetIds.clear();
 
    if (!limitFilterToEB_) {
 
       if (debug_)
          std::cout << "process EE" << std::endl;
 
       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) {
                //std::cout << "Neighbouring dead channel with status: " << *sit << std::endl;
                if (channelAllowed == *sit || (channelAllowed < 0 && 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);
          const CaloCellGeometry* cellGeom = subGeom->getGeometry(currDetId);
          double eta = cellGeom->getPosition().eta();
 
          if (!detIdAlreadyChecked && deadNeighbourStati.size() == 0 && eeBoundaryCalc.checkRecHitHasInvalidNeighbour(
                *hit, ecalStatus) && abs(eta) < 1.6) {
 
             if (debug_)
                eeBoundaryCalc.setDebugMode();
             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_)
                   std::cout << "EE: gap cluster energy: " << gapinfo.boundaryEnergy << " deadCells: "
                         << gapinfo.detIds.size() << std::endl;
             }
          }
 
          // RecHit is member of boundary and should be processed
          if (!detIdAlreadyChecked && (passChannelLimitation || (limitDeadCellToChannelStatusEE_.size() == 0
                && deadNeighbourStati.size() > 0))) {
 
             if (debug_)
                eeBoundaryCalc.setDebugMode();
             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_)
                   std::cout << "EE: boundary Energy dead RecHit: " << boundinfo.boundaryEnergy << " ET: "
                         << boundinfo.boundaryET << " deadCells: " << boundinfo.detIds.size() << std::endl;
 
                //               for (std::vector<DetId>::iterator it = boundinfo.detIds.begin(); it != boundinfo.detIds.end(); it++) {
                //                  std::cout << (EEDetId) * it << std::endl;
                //               }
 
             }
 
          }
       }
 
    } 
 
    sameFlagDetIds.clear();
 
    std::auto_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_);
    pass = (!isBoundary && ((!isGap && enableGap_) || !enableGap_));
 
    iEvent.put(pAnomalousECALVariables, "anomalousECALVariables");
 
    iEvent.put( std::auto_ptr<bool>(new 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::auto_ptr<AnomalousECALVariables> pAnomalousECALVariables(new AnomalousECALVariables(v_enNeighboursGap_EB,
             v_enNeighboursGap_EE, v_boundaryInfoDeadCells_EB, v_boundaryInfoDeadCells_EE));
       iEvent.put(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::auto_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;
 }