#include <EcalBoundaryInfoCalculator.h>

Public Member Functions
BoundaryInformation	boundaryRecHits (const edm::Handle< EcalRecHitCollection > &, const EcalRecHit *, const edm::ESHandle< CaloTopology > theCaloTopology, const edm::ESHandle< EcalChannelStatus > ecalStatus, const edm::ESHandle< CaloGeometry > geometry)

bool	checkRecHitHasDeadNeighbour (const EcalRecHit &hit, const edm::ESHandle< EcalChannelStatus > ecalStatus, std::vector< int > &stati)

bool	checkRecHitHasInvalidNeighbour (const EcalRecHit &hit, const edm::ESHandle< EcalChannelStatus > ecalStatus)

	EcalBoundaryInfoCalculator ()

BoundaryInformation	gapRecHits (const edm::Handle< EcalRecHitCollection > &, const EcalRecHit *, const edm::ESHandle< CaloTopology > theCaloTopology, const edm::ESHandle< EcalChannelStatus > ecalStatus, const edm::ESHandle< CaloGeometry > geometry)

void	setDebugMode ()

	~EcalBoundaryInfoCalculator ()

Private Member Functions
CdOrientation	goBackOneCell (CdOrientation currDirection, EcalDetId prev)

void	initializeEcalNavigator (DetId startE, const edm::ESHandle< CaloTopology > theCaloTopology, EcalSubdetector ecalSubDet)

EcalDetId	makeStepInDirection (CdOrientation direction, CaloNavigator< EcalDetId > *theNavi)

CdOrientation	turnLeft (CdOrientation currDirection, bool reverseOrientation)

CdOrientation	turnRight (CdOrientation currDirection, bool reverseOrientation)

Private Attributes
bool	debug

std::map< CdOrientation, CdOrientation >	nextDirs

std::map< CdOrientation, CdOrientation >	oppositeDirs

std::map< CdOrientation, CdOrientation >	prevDirs

CaloNavigator< EcalDetId > *	theEcalNav

Detailed Description

template<class EcalDetId>
class EcalBoundaryInfoCalculator< EcalDetId >

Definition at line 24 of file EcalBoundaryInfoCalculator.h.

Constructor & Destructor Documentation

template<class EcalDetId >

EcalBoundaryInfoCalculator< EcalDetId >::EcalBoundaryInfoCalculator ( )

Definition at line 305 of file EcalBoundaryInfoCalculator.h.

References debug, east, north, south, and west.

                                                                                             {
 
     nextDirs.clear();
     nextDirs[north] = east;
     nextDirs[east] = south;
     nextDirs[south] = west;
     nextDirs[west] = north;
 
     prevDirs.clear();
     prevDirs[north] = west;
     prevDirs[east] = north;
     prevDirs[south] = east;
     prevDirs[west] = south;
 
     oppositeDirs.clear();
     oppositeDirs[north] = south;
     oppositeDirs[south] = north;
     oppositeDirs[east] = west;
     oppositeDirs[west] = east;
 
     theEcalNav = 0;
     debug = false;
 
 }

template<class EcalDetId >

EcalBoundaryInfoCalculator< EcalDetId >::~EcalBoundaryInfoCalculator ( )

Definition at line 330 of file EcalBoundaryInfoCalculator.h.

                                                                                              {
     delete theEcalNav;
 }

Member Function Documentation

template<class EcalDetId >

BoundaryInformation EcalBoundaryInfoCalculator< EcalDetId >::boundaryRecHits	(	const edm::Handle< EcalRecHitCollection > &	RecHits,
		const EcalRecHit *	hit,
		const edm::ESHandle< CaloTopology >	theCaloTopology,
		const edm::ESHandle< EcalChannelStatus >	ecalStatus,
		const edm::ESHandle< CaloGeometry >	geometry
	)

Definition at line 334 of file EcalBoundaryInfoCalculator.h.

References BoundaryInformation::boundaryEnergy, BoundaryInformation::boundaryET, BoundaryInformation::channelStatus, gather_cfg::cout, cond::rpcobimon::current, debug, BoundaryInformation::detIds, EcalBarrel, EcalEndcap, EcalRecHit::energy(), PV3DBase< T, PVType, FrameType >::eta(), eta(), CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), EcalRecHit::id(), GetRecoTauVFromDQM_MC_cff::next, BoundaryInformation::nextToBorder, north, BoundaryInformation::recHits, alignCSCRings::s, dqm_diff::start, ntuplemaker::status, and BoundaryInformation::subdet.

Referenced by EcalDeadCellBoundaryEnergyFilter::filter().

                                                                                        {
 
     //initialize boundary information
     std::vector<EcalRecHit> boundaryRecHits;
     std::vector<DetId> boundaryDetIds;
     std::vector<int> stati;
 
     double boundaryEnergy = 0;
     double boundaryET = 0;
     int beCellCounter = 0;
     bool nextToBorder = false;
 
     boundaryRecHits.push_back(*hit);
     ++beCellCounter;
     boundaryEnergy += hit->energy();
     EcalDetId hitdetid = (EcalDetId) hit->id();
     boundaryDetIds.push_back(hitdetid);
     const CaloSubdetectorGeometry* subGeom = geometry->getSubdetectorGeometry(hitdetid);
     const CaloCellGeometry* cellGeom = subGeom->getGeometry(hitdetid);
     double eta = cellGeom->getPosition().eta();
     boundaryET += hit->energy() / cosh(eta);
 
     if (debug) {
         std::cout << "Find Boundary RecHits..." << std::endl;
 
         if (hitdetid.subdet() == EcalBarrel) {
             std::cout << "Starting at : (" << ((EBDetId) hitdetid).ieta() << "," << ((EBDetId) hitdetid).iphi() << ")"
             << std::endl;
 
         } else if (hitdetid.subdet() == EcalEndcap) {
             std::cout << "Starting at : (" << ((EEDetId) hitdetid).ix() << "," << ((EEDetId) hitdetid).iy() << ")"
             << std::endl;
         }
     }
 
     //initialize navigator
     initializeEcalNavigator(hitdetid, theCaloTopology, EcalDetId::subdet());
     CdOrientation currDirection = north;
     bool reverseOrientation = false;
 
     EcalDetId next(0);
     EcalDetId start = hitdetid;
     EcalDetId current = start;
     int current_status = 0;
 
     // Search until a dead cell is ahead
     bool startAlgo = false;
     int noDirs = 0;
     while (!startAlgo) {
         next = makeStepInDirection(currDirection, theEcalNav);
         theEcalNav->setHome(current);
         theEcalNav->home();
         EcalChannelStatus::const_iterator chit = ecalStatus->find(next);
         int status = (chit != ecalStatus->end()) ? chit->getStatusCode() & 0x1F : -1;
         if (status > 0) {
             stati.push_back(status);
             startAlgo = true;
             break;
         }
         currDirection = turnLeft(currDirection, reverseOrientation);
         ++noDirs;
         if (noDirs > 4) {
 
             std::cout << "No starting direction can be found: This should never happen if RecHit has a dead neighbour!" << std::endl;
             throw "ERROR";
             break;
         }
     }
 
     // go around dead clusters counter clock wise
     currDirection = turnRight(currDirection, reverseOrientation);
 
     // Search for next boundary element
     bool nextIsStart = false;
     bool atBorder = false;
 
     while (!nextIsStart) {
 
         bool nextStepFound = false;
         int status = 0;
         noDirs = 0;
         while (!nextStepFound) {
             next = makeStepInDirection(currDirection, theEcalNav);
             theEcalNav->setHome(current);
             theEcalNav->home();
             EcalChannelStatus::const_iterator chit = ecalStatus->find(next);
             status = (chit != ecalStatus->end()) ? chit->getStatusCode() & 0x1F : -1;
             if (status > 0) {
                 // New dead cell found: update status std::vector of dead channels
                 bool present = false;
                 for (std::vector<int>::const_iterator s = stati.begin(); s != stati.end(); ++s) {
                     if (*s == status) {
                         present = true;
                         break;
                     }
                 }
                 if (!present)
                     stati.push_back(status);
 
                 if (atBorder) {
                     nextStepFound = true;
                 } else {
                     currDirection = turnRight(currDirection, reverseOrientation);
                 }
             } else if (next == EcalDetId(0)) {
                 // In case the Ecal border is reached -> go along dead cells
                 currDirection = turnLeft(currDirection, reverseOrientation);
                 atBorder = true;
             } else if (status == 0) {
                 nextStepFound = true;
             }
             ++noDirs;
             if (noDirs > 4) {
                 std::cout << "No valid next direction can be found: This should never happen!" << std::endl;
                 throw "ERROR";
                 break;
             }
         }
 
         // make next step
         next = makeStepInDirection(currDirection, theEcalNav);
 
         if (next == start) {
             nextIsStart = true;
             if (debug)
                 std::cout << "Boundary path reached starting position!" << std::endl;
         }
 
         if (debug)
             std::cout << "Next step: " << (EcalDetId) next << " Status: " << status << " Start: " << (EcalDetId) start << std::endl;
 
         // save recHits and add energy if on the boundary (and not inside at border)
         if ((!atBorder || status == 0) && !nextIsStart) {
             boundaryDetIds.push_back(next);
             if (RecHits->find(next) != RecHits->end() && status == 0) {
                 EcalRecHit nexthit = *RecHits->find(next);
                 ++beCellCounter;
                 boundaryRecHits.push_back(nexthit);
                 boundaryEnergy += nexthit.energy();
                 cellGeom = subGeom->getGeometry(hitdetid);
                 eta = cellGeom->getPosition().eta();
                 boundaryET += nexthit.energy() / cosh(eta);
             }
         }
 
         if (current_status == 0 && status == 0 && atBorder) {
             // this is for a special case, where dead cells are at border corner
             currDirection = turnRight(currDirection, reverseOrientation);
         } else {
             // if dead region along a border is left, turn left
             if (status == 0 && atBorder) {
                 atBorder = false;
                 currDirection = turnLeft(currDirection, reverseOrientation);
             }
             if (status == 0) {
                 // if outside the cluster turn left to follow boundary
                 currDirection = turnLeft(currDirection, reverseOrientation);
             } else {
                 // else turn right to check if dead region can be left
                 currDirection = turnRight(currDirection, reverseOrientation);
             }
         }
 
         // save currect position
         current = next;
         current_status = status;
 
     }
 
     if (debug) {
         std::cout << "<<<<<<<<<<<<<<< Final Boundary object <<<<<<<<<<<<<<<" << std::endl;
         std::cout << "no of neighbouring RecHits: " << boundaryRecHits.size() << std::endl;
         std::cout << "no of neighbouring DetIds: " << boundaryDetIds.size() << std::endl;
         std::cout << "boundary energy: " << boundaryEnergy << std::endl;
         std::cout << "boundary ET: " << boundaryET << std::endl;
         std::cout << "no of cells contributing to boundary energy: " << beCellCounter << std::endl;
         std::cout << "Channel stati: ";
         for (std::vector<int>::iterator it = stati.begin(); it != stati.end(); ++it) {
             std::cout << *it << " ";
         }
         std::cout << std::endl;
     }
 
     BoundaryInformation boundInfo;
     boundInfo.subdet = hitdetid.subdet();
     boundInfo.detIds = boundaryDetIds;
     boundInfo.recHits = boundaryRecHits;
     boundInfo.boundaryEnergy = boundaryEnergy;
     boundInfo.boundaryET = boundaryET;
     boundInfo.nextToBorder = nextToBorder;
     boundInfo.channelStatus = stati;
 
     if (theEcalNav != 0) {
         delete theEcalNav;
         theEcalNav = 0;
     }
     return boundInfo;
 }

template<class EcalDetId>

bool EcalBoundaryInfoCalculator< EcalDetId >::checkRecHitHasDeadNeighbour	(	const EcalRecHit &	hit,
		const edm::ESHandle< EcalChannelStatus >	ecalStatus,
		std::vector< int > &	stati
	)

inline

Definition at line 39 of file EcalBoundaryInfoCalculator.h.

Referenced by EcalDeadCellBoundaryEnergyFilter::filter().

                                                   {
 
         stati.clear();
         EcalDetId hitdetid = EcalDetId(hit.id());
 
         if (hitdetid.subdet() == EcalBarrel) {
 
             EBDetId ebhitdetid = (EBDetId) hitdetid;
 
             int hitIeta = ebhitdetid.ieta();
             int hitIphi = ebhitdetid.iphi();
 
             for (int ieta = -1; ieta <= 1; ieta++) {
                 for (int iphi = -1; iphi <= 1; iphi++) {
                     if ((iphi == 0 && ieta == 0) || iphi * ieta != 0)
                         //if (iphi == 0 && ieta == 0)
                         continue;
                     int neighbourIeta = hitIeta + ieta;
                     int neighbourIphi = hitIphi + iphi;
                     if (!EBDetId::validDetId(neighbourIeta, neighbourIphi)) {
                         if (neighbourIphi < 1)
                             neighbourIphi += 360;
                         if (neighbourIphi > 360)
                             neighbourIphi -= 360;
                         if (neighbourIeta == 0) {
                             neighbourIeta += ieta;
                         }
                     }
 
                     if (EBDetId::validDetId(neighbourIeta, neighbourIphi)) {
 
                         const EBDetId detid = EBDetId(neighbourIeta, neighbourIphi, EBDetId::ETAPHIMODE);
                         EcalChannelStatus::const_iterator chit = ecalStatus->find(detid);
                         int status = (chit != ecalStatus->end()) ? chit->getStatusCode() & 0x1F : -1;
 
                         if (status > 0) {
                             bool present = false;
                             for (std::vector<int>::const_iterator s = stati.begin(); s != stati.end(); ++s) {
                                 if (*s == status) {
                                     present = true;
                                     break;
                                 }
                             }
                             if (!present)
                                 stati.push_back(status);
                         }
                     }
                 }
             }
 
         } else if (hitdetid.subdet() == EcalEndcap) {
 
             EEDetId eehitdetid = (EEDetId) hitdetid;
             int hitIx = eehitdetid.ix();
             int hitIy = eehitdetid.iy();
             int hitIz = eehitdetid.zside();
 
             for (int ix = -1; ix <= 1; ix++) {
                 for (int iy = -1; iy <= 1; iy++) {
                     if ((ix == 0 && iy == 0) || ix * iy != 0)
                         //if (ix == 0 && iy == 0)
                         continue;
                     int neighbourIx = hitIx + ix;
                     int neighbourIy = hitIy + iy;
 
                     if (EEDetId::validDetId(neighbourIx, neighbourIy, hitIz)) {
 
                         const EEDetId detid = EEDetId(neighbourIx, neighbourIy, hitIz, EEDetId::XYMODE);
                         EcalChannelStatus::const_iterator chit = ecalStatus->find(detid);
                         int status = (chit != ecalStatus->end()) ? chit->getStatusCode() & 0x1F : -1;
 
                         if (status > 0) {
                             bool present = false;
                             for (std::vector<int>::const_iterator s = stati.begin(); s != stati.end(); ++s) {
                                 if (*s == status) {
                                     present = true;
                                     break;
                                 }
                             }
                             if (!present)
                                 stati.push_back(status);
                         }
                     }
                 }
             }
 
         } else {
             std::cout << "ERROR - RecHit belongs to wrong sub detector" << std::endl;
         }
 
         if (stati.size() > 0)
             return true;
         return false;
 
     }

template<class EcalDetId>

bool EcalBoundaryInfoCalculator< EcalDetId >::checkRecHitHasInvalidNeighbour	(	const EcalRecHit &	hit,
		const edm::ESHandle< EcalChannelStatus >	ecalStatus
	)

inline

Definition at line 136 of file EcalBoundaryInfoCalculator.h.

Referenced by EcalDeadCellBoundaryEnergyFilter::filter().

                                                                                                                 {
 
         EcalDetId hitdetid = EcalDetId(hit.id());
 
         if (hitdetid.subdet() == EcalBarrel) {
 
             EBDetId ebhitdetid = (EBDetId) hitdetid;
 
             int hitIeta = ebhitdetid.ieta();
             int hitIphi = ebhitdetid.iphi();
 
             for (int ieta = -1; ieta <= 1; ieta++) {
                 for (int iphi = -1; iphi <= 1; iphi++) {
                     if ((iphi == 0 && ieta == 0) || iphi * ieta != 0)
                         //if (iphi == 0 && ieta == 0)
                         continue;
                     int neighbourIeta = hitIeta + ieta;
                     int neighbourIphi = hitIphi + iphi;
                     if (!EBDetId::validDetId(neighbourIeta, neighbourIphi)) {
                         if (neighbourIphi < 1)
                             neighbourIphi += 360;
                         if (neighbourIphi > 360)
                             neighbourIphi -= 360;
                         if (neighbourIeta == 0) {
                             neighbourIeta += ieta;
                         }
                     }
 
                     if (!EBDetId::validDetId(neighbourIeta, neighbourIphi)) {
                         return true;
                     }
                 }
             }
 
         } else if (hitdetid.subdet() == EcalEndcap) {
 
             EEDetId eehitdetid = (EEDetId) hitdetid;
             int hitIx = eehitdetid.ix();
             int hitIy = eehitdetid.iy();
             int hitIz = eehitdetid.zside();
 
             for (int ix = -1; ix <= 1; ix++) {
                 for (int iy = -1; iy <= 1; iy++) {
                     if ((ix == 0 && iy == 0) || ix * iy != 0)
                         //if (ix == 0 && iy == 0)
                         continue;
                     int neighbourIx = hitIx + ix;
                     int neighbourIy = hitIy + iy;
 
                     if (!EEDetId::validDetId(neighbourIx, neighbourIy, hitIz)) {
                         return true;
                     }
                 }
             }
 
         } else {
             std::cout << "ERROR - RecHit belongs to wrong sub detector" << std::endl;
         }
 
         return false;
     }

template<class EcalDetId >

BoundaryInformation EcalBoundaryInfoCalculator< EcalDetId >::gapRecHits	(	const edm::Handle< EcalRecHitCollection > &	RecHits,
		const EcalRecHit *	hit,
		const edm::ESHandle< CaloTopology >	theCaloTopology,
		const edm::ESHandle< EcalChannelStatus >	ecalStatus,
		const edm::ESHandle< CaloGeometry >	geometry
	)

Definition at line 535 of file EcalBoundaryInfoCalculator.h.

References BoundaryInformation::boundaryEnergy, BoundaryInformation::boundaryET, BoundaryInformation::channelStatus, gather_cfg::cout, cond::rpcobimon::current, debug, BoundaryInformation::detIds, EcalBarrel, EcalEndcap, EcalRecHit::energy(), PV3DBase< T, PVType, FrameType >::eta(), eta(), CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), EcalRecHit::id(), GetRecoTauVFromDQM_MC_cff::next, BoundaryInformation::nextToBorder, north, BoundaryInformation::recHits, dqm_diff::start, ntuplemaker::status, and BoundaryInformation::subdet.

Referenced by EcalDeadCellBoundaryEnergyFilter::filter().

                                                                                        {
 
     //initialize boundary information
     std::vector<EcalRecHit> gapRecHits;
     std::vector<DetId> gapDetIds;
 
     double gapEnergy = 0;
     double gapET = 0;
     int gapCellCounter = 0;
     bool nextToBorder = false;
 
     gapRecHits.push_back(*hit);
     ++gapCellCounter;
     gapEnergy += hit->energy();
     EcalDetId hitdetid = (EcalDetId) hit->id();
     gapDetIds.push_back(hitdetid);
     const CaloSubdetectorGeometry* subGeom = geometry->getSubdetectorGeometry(hitdetid);
     const CaloCellGeometry* cellGeom = subGeom->getGeometry(hitdetid);
     double eta = cellGeom->getPosition().eta();
     gapET += hit->energy() / cosh(eta);
 
     if (debug) {
         std::cout << "Find Border RecHits..." << std::endl;
 
         if (hitdetid.subdet() == EcalBarrel) {
             std::cout << "Starting at : (" << ((EBDetId) hitdetid).ieta() << "," << ((EBDetId) hitdetid).iphi() << ")"
             << std::endl;
 
         } else if (hitdetid.subdet() == EcalEndcap) {
             std::cout << "Starting at : (" << ((EEDetId) hitdetid).ix() << "," << ((EEDetId) hitdetid).iy() << ")"
             << std::endl;
         }
     }
 
     //initialize navigator
     initializeEcalNavigator(hitdetid, theCaloTopology, EcalDetId::subdet());
     CdOrientation currDirection = north;
     bool reverseOrientation = false;
 
     EcalDetId next(0);
     EcalDetId start = hitdetid;
     EcalDetId current = start;
 
     // Search until a invalid cell is ahead
     bool startAlgo = false;
     int noDirs = 0;
     while (!startAlgo) {
         next = makeStepInDirection(currDirection, theEcalNav);
         theEcalNav->setHome(start);
         theEcalNav->home();
         if (next == EcalDetId(0)) {
             startAlgo = true;
             nextToBorder = true;
             break;
         }
         currDirection = turnLeft(currDirection, reverseOrientation);
         ++noDirs;
         if (noDirs > 4) {
 
             std::cout << "No starting direction can be found: This should never happen if RecHit is at border!" << std::endl;
             throw "ERROR";
             break;
         }
     }
 
     CdOrientation startDirection = currDirection;
     currDirection = turnLeft(currDirection, reverseOrientation);
 
     // Search for next border element
     bool endIsFound = false;
     bool startIsEnd = false;
 
     while (!endIsFound) {
 
         bool nextStepFound = false;
         int status = 0;
         noDirs = 0;
         while (!nextStepFound) {
             next = makeStepInDirection(currDirection, theEcalNav);
             theEcalNav->setHome(current);
             theEcalNav->home();
             EcalChannelStatus::const_iterator chit = ecalStatus->find(next);
             status = (chit != ecalStatus->end()) ? chit->getStatusCode() & 0x1F : -1;
             if (status > 0) {
                 // Find dead cell along border -> end of cluster
                 endIsFound = true;
                 break;
             } else if (next == EcalDetId(0)) {
                 // In case the Ecal border -> go along gap
                 currDirection = turnLeft(currDirection, reverseOrientation);
             } else if (status == 0) {
                 if (RecHits->find(next) != RecHits->end()) {
                     nextStepFound = true;
                 } else {
                     endIsFound = true;
                     break;
                 }
             }
             ++noDirs;
             if (noDirs > 4) {
                 std::cout << "No valid next direction can be found: This should never happen!" << std::endl;
                 throw "ERROR";
                 break;
             }
         }
 
         // make next step
         next = makeStepInDirection(currDirection, theEcalNav);
         current = next;
 
         if (next == start) {
             startIsEnd = true;
             endIsFound = true;
             if (debug)
                 std::cout << "Path along gap reached starting position!" << std::endl;
         }
 
         if (debug) {
             std::cout << "Next step: " << (EcalDetId) next << " Status: " << status << " Start: " << (EcalDetId) start << std::endl;
             if (endIsFound)
                 std::cout << "End of gap cluster is found going left" << std::endl;
         }
 
         // save recHits and add energy
         if (!endIsFound) {
             gapDetIds.push_back(next);
             if (RecHits->find(next) != RecHits->end()) {
                 EcalRecHit nexthit = *RecHits->find(next);
                 ++gapCellCounter;
                 gapRecHits.push_back(nexthit);
                 gapEnergy += nexthit.energy();
                 cellGeom = subGeom->getGeometry(next);
                 eta = cellGeom->getPosition().eta();
                 gapET += nexthit.energy() / cosh(eta);
             }
         }
 
         // turn right to follow gap
         currDirection = turnRight(currDirection, reverseOrientation);
 
     }
 
     theEcalNav->setHome(start);
     theEcalNav->home();
     current = start;
     currDirection = startDirection;
     currDirection = turnRight(currDirection, reverseOrientation);
 
     // Search for next border element
     endIsFound = false;
 
     if (!startIsEnd) {
 
         while (!endIsFound) {
 
             bool nextStepFound = false;
             int status = 0;
             noDirs = 0;
             while (!nextStepFound) {
                 next = makeStepInDirection(currDirection, theEcalNav);
                 theEcalNav->setHome(current);
                 theEcalNav->home();
                 EcalChannelStatus::const_iterator chit = ecalStatus->find(next);
                 status = (chit != ecalStatus->end()) ? chit->getStatusCode() & 0x1F : -1;
                 if (status > 0) {
                     // Find dead cell along border -> end of cluster
                     endIsFound = true;
                     break;
                 } else if (next == EcalDetId(0)) {
                     // In case the Ecal border -> go along gap
                     currDirection = turnRight(currDirection, reverseOrientation);
                 } else if (status == 0) {
                     if (RecHits->find(next) != RecHits->end()) {
                         nextStepFound = true;
                     } else {
                         endIsFound = true;
                         break;
                     }
                 }
                 ++noDirs;
                 if (noDirs > 4) {
                     std::cout << "No valid next direction can be found: This should never happen!" << std::endl;
                     throw "ERROR";
                     break;
                 }
             }
 
             // make next step
             next = makeStepInDirection(currDirection, theEcalNav);
             current = next;
 
             if (debug) {
                 std::cout << "Next step: " << (EcalDetId) next << " Status: " << status << " Start: " << (EcalDetId) start
                 << std::endl;
                 if (endIsFound)
                     std::cout << "End of gap cluster is found going right" << std::endl;
             }
 
             // save recHits and add energy
             if (!endIsFound) {
                 gapDetIds.push_back(next);
                 if (RecHits->find(next) != RecHits->end()) {
                     EcalRecHit nexthit = *RecHits->find(next);
                     ++gapCellCounter;
                     gapRecHits.push_back(nexthit);
                     gapEnergy += nexthit.energy();
                     cellGeom = subGeom->getGeometry(next);
                     eta = cellGeom->getPosition().eta();
                     gapET += nexthit.energy() / cosh(eta);
                 }
             }
 
             // turn left to follow gap
             currDirection = turnLeft(currDirection, reverseOrientation);
 
         }
     }
 
     if (debug) {
         std::cout << "<<<<<<<<<<<<<<< Final Gap object <<<<<<<<<<<<<<<" << std::endl;
         std::cout << "No of RecHits along gap: " << gapRecHits.size() << std::endl;
         std::cout << "No of DetIds along gap: " << gapDetIds.size() << std::endl;
         std::cout << "Gap energy: " << gapEnergy << std::endl;
         std::cout << "Gap ET: " << gapET << std::endl;
     }
 
     BoundaryInformation gapInfo;
     gapInfo.subdet = hitdetid.subdet();
     gapInfo.detIds = gapDetIds;
     gapInfo.recHits = gapRecHits;
     gapInfo.boundaryEnergy = gapEnergy;
     gapInfo.boundaryET = gapET;
     gapInfo.nextToBorder = nextToBorder;
     std::vector<int> stati;
     gapInfo.channelStatus = stati;
 
     if (theEcalNav != 0) {
         delete theEcalNav;
         theEcalNav = 0;
     }
     return gapInfo;
 }

template<class EcalDetId>

CdOrientation EcalBoundaryInfoCalculator< EcalDetId >::goBackOneCell	(	CdOrientation	currDirection,
		EcalDetId	prev
	)

inlineprivate

Definition at line 235 of file EcalBoundaryInfoCalculator.h.

                                                                              {
         std::map<CdOrientation, CdOrientation>::iterator oIt = oppositeDirs.find(currDirection);
         CdOrientation oppDirection=none;
         if (oIt != oppositeDirs.end()) {
             oppDirection = oIt->second;
             theEcalNav->setHome(prev);
         }
         EcalDetId currDetId = theEcalNav->pos();
 
         return oppDirection;
     }

template<class EcalDetId>

void EcalBoundaryInfoCalculator< EcalDetId >::initializeEcalNavigator	(	DetId	startE,
		const edm::ESHandle< CaloTopology >	theCaloTopology,
		EcalSubdetector	ecalSubDet
	)

inlineprivate

Definition at line 275 of file EcalBoundaryInfoCalculator.h.

                                                              {
         if (ecalSubDet == EcalBarrel) {
             if (theEcalNav != 0) {
                 delete theEcalNav;
                 theEcalNav = 0;
             }
             theEcalNav = new CaloNavigator<EcalDetId> ((EBDetId) startE, (theCaloTopology->getSubdetectorTopology(
                              DetId::Ecal, ecalSubDet)));
         } else if (ecalSubDet == EcalEndcap) {
             if (theEcalNav != 0) {
                 delete theEcalNav;
                 theEcalNav = 0;
             }
             theEcalNav = new CaloNavigator<EcalDetId> ((EEDetId) startE, (theCaloTopology->getSubdetectorTopology(
                              DetId::Ecal, ecalSubDet)));
         } else {
             std::cout << "initializeEcalNavigator not implemented for subDet: " << ecalSubDet << std::endl;
         }
 
     }

template<class EcalDetId>

EcalDetId EcalBoundaryInfoCalculator< EcalDetId >::makeStepInDirection	(	CdOrientation	direction,
		CaloNavigator< EcalDetId > *	theNavi
	)

inlineprivate

Definition at line 206 of file EcalBoundaryInfoCalculator.h.

                                                                                                {
         EcalDetId next;
         switch (direction) {
         case north: {
                 //std::cout<<"go north"<<std::endl;
                 next = theNavi->north();
                 break;
             }
         case east: {
                 //std::cout<<"go east"<<std::endl;
                 next = theNavi->east();
                 break;
             }
         case south: {
                 //std::cout<<"go south"<<std::endl;
                 next = theNavi->south();
                 break;
             }
         case west: {
                 //std::cout<<"go west"<<std::endl;
                 next = theNavi->west();
                 break;
             }
         default:
         break;
         }
         return next;
     }

template<class EcalDetId>

void EcalBoundaryInfoCalculator< EcalDetId >::setDebugMode ( )

inline

Definition at line 199 of file EcalBoundaryInfoCalculator.h.

Referenced by EcalDeadCellBoundaryEnergyFilter::filter().

                         {
         std::cout << "set Debug Mode!" << std::endl;
         debug = true;
     }

template<class EcalDetId>

CdOrientation EcalBoundaryInfoCalculator< EcalDetId >::turnLeft	(	CdOrientation	currDirection,
		bool	reverseOrientation
	)

inlineprivate

Definition at line 261 of file EcalBoundaryInfoCalculator.h.

                                                                                  {
         //read nextDirection
         std::map<CdOrientation, CdOrientation> turnMap = prevDirs;
         if (reverseOrientation)
             turnMap = nextDirs;
         std::map<CdOrientation, CdOrientation>::iterator nIt = turnMap.find(currDirection);
         CdOrientation nextDirection=none;
         if (nIt != turnMap.end())
             nextDirection = (*nIt).second;
         else
             std::cout << "ERROR - no Next Direction found!?!?" << std::endl;
         return nextDirection;
     }

template<class EcalDetId>

CdOrientation EcalBoundaryInfoCalculator< EcalDetId >::turnRight	(	CdOrientation	currDirection,
		bool	reverseOrientation
	)

inlineprivate

Definition at line 247 of file EcalBoundaryInfoCalculator.h.

                                                                                   {
         //read nextDirection
         std::map<CdOrientation, CdOrientation> turnMap = nextDirs;
         if (reverseOrientation)
             turnMap = prevDirs;
         std::map<CdOrientation, CdOrientation>::iterator nIt = turnMap.find(currDirection);
         CdOrientation nextDirection=none;
         if (nIt != turnMap.end())
             nextDirection = (*nIt).second;
         else
             std::cout << "ERROR - no Next Direction found!?!?" << std::endl;
         return nextDirection;
     }