Producer for particle flow rechits (PFRecHit) in ECAL. More...

#include <PFRecHitProducerECAL.h>

Inheritance diagram for PFRecHitProducerECAL:

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

	~PFRecHitProducerECAL ()

Public Member Functions inherited from PFRecHitProducer
virtual void	beginRun (edm::Run &run, const edm::EventSetup &es)

virtual void	endRun ()

	PFRecHitProducer (const edm::ParameterSet &)

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

	~PFRecHitProducer ()

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

virtual	~EDProducer ()

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

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

Private Member Functions
reco::PFRecHit *	createEcalRecHit (const DetId &detid, double energy, PFLayer::Layer layer, const CaloSubdetectorGeometry *geom)

void	createRecHits (std::vector< reco::PFRecHit > &rechits, std::vector< reco::PFRecHit > &rechitsCleaned, edm::Event &, const edm::EventSetup &)

void	ecalNeighbArray (const EcalBarrelGeometry &barrelGeom, const CaloSubdetectorTopology &barrelTopo, const EcalEndcapGeometry &endcapGeom, const CaloSubdetectorTopology &endcapTopo)

bool	findEcalRecHitGeometry (const DetId &detid, const CaloSubdetectorGeometry *geom, math::XYZVector &position, math::XYZVector &axis)
	find the position and the axis of the cell for a given rechit More...

void	findRecHitNeighboursECAL (reco::PFRecHit &rh, const std::map< unsigned, unsigned > &sortedHits)
	find rechit neighbours, using the hashed index More...

DetId	move (DetId cell, const CaloDirection &dir) const

bool	stdmove (DetId &cell, const CaloDirection &dir, const CaloSubdetectorTopology &barrelTopo, const CaloSubdetectorTopology &endcapTopo, const EcalBarrelGeometry &barrelGeom, const EcalEndcapGeometry &endcapGeom) const

bool	stdsimplemove (DetId &cell, const CaloDirection &dir, const CaloSubdetectorTopology &barrelTopo, const CaloSubdetectorTopology &endcapTopo, const EcalBarrelGeometry &barrelGeom, const EcalEndcapGeometry &endcapGeom) const

Private Attributes
bool	crossBarrelEndcapBorder_
	if true, navigation will cross the barrel-endcap border More...

edm::InputTag	inputTagEcalRecHitsEB_

edm::InputTag	inputTagEcalRecHitsEE_

bool	neighbourmapcalculated_
	set to true in ecalNeighbArray More...

std::vector< std::vector< DetId > >	neighboursEB_
	for each ecal barrel rechit, keep track of the neighbours More...

std::vector< std::vector< DetId > >	neighboursEE_
	for each ecal endcap rechit, keep track of the neighbours More...

double	threshCleaning_

bool	timingCleaning_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

typedef WorkerT< EDProducer >	WorkerType

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

Protected Types inherited from PFRecHitProducer
typedef std::map< unsigned, unsigned >::const_iterator	IDH

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Protected Attributes inherited from PFRecHitProducer
const HcalPFCorrs *	myPFCorr

const EcalChannelStatus *	theEcalChStatus

const HcalChannelQuality *	theHcalChStatus

const CaloTowerConstituentsMap *	theTowerConstituentsMap

double	thresh_Barrel_
	rechits with E < threshold will not give rise to a PFRecHit More...

double	thresh_Endcap_

bool	verbose_
	verbose ? More...

Detailed Description

Producer for particle flow rechits (PFRecHit) in ECAL.

Author: Colin Bernet

Date: february 2008

Definition at line 41 of file PFRecHitProducerECAL.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 36 of file PFRecHitProducerECAL.cc.

References crossBarrelEndcapBorder_, edm::ParameterSet::getParameter(), inputTagEcalRecHitsEB_, inputTagEcalRecHitsEE_, neighbourmapcalculated_, threshCleaning_, and timingCleaning_.

  : PFRecHitProducer(iConfig) {
 
   // access to the collections of rechits
 
   inputTagEcalRecHitsEB_ = 
     iConfig.getParameter<InputTag>("ecalRecHitsEB");
 
   inputTagEcalRecHitsEE_ = 
     iConfig.getParameter<InputTag>("ecalRecHitsEE");
   
   crossBarrelEndcapBorder_ =
     iConfig.getParameter<bool>("crossBarrelEndcapBorder");
 
   timingCleaning_ = 
     iConfig.getParameter<bool>("timing_Cleaning");
 
   threshCleaning_ = 
     iConfig.getParameter<double>("thresh_Cleaning");
 
   neighbourmapcalculated_ = false;
 }

PFRecHitProducerECAL::~PFRecHitProducerECAL ( )

Definition at line 64 of file PFRecHitProducerECAL.cc.

64 {}

Member Function Documentation

reco::PFRecHit * PFRecHitProducerECAL::createEcalRecHit	(	const DetId &	detid,
		double	energy,
		PFLayer::Layer	layer,
		const CaloSubdetectorGeometry *	geom
	)

private

Definition at line 252 of file PFRecHitProducerECAL.cc.

References relval_parameters_module::energy, CaloCellGeometry::getCorners(), CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), TruncatedPyramid::getPosition(), position, DetId::rawId(), reco::PFRecHit::setNECorner(), reco::PFRecHit::setNWCorner(), reco::PFRecHit::setSECorner(), reco::PFRecHit::setSWCorner(), PV3DBase< T, PVType, FrameType >::x(), ExpressReco_HICollisions_FallBack::x, PV3DBase< T, PVType, FrameType >::y(), ExpressReco_HICollisions_FallBack::y, z, and PV3DBase< T, PVType, FrameType >::z().

Referenced by createRecHits().

                                                           {
 
   math::XYZVector position;
   math::XYZVector axis;
 
   const CaloCellGeometry *thisCell 
     = geom->getGeometry(detid);
   
   // find rechit geometry
   if(!thisCell) {
     LogError("PFRecHitProducerECAL")
       <<"warning detid "<<detid.rawId()
       <<" not found in geometry"<<endl;
     return 0;
   }
   
   position.SetCoordinates ( thisCell->getPosition().x(),
                 thisCell->getPosition().y(),
                 thisCell->getPosition().z() );
 
   
   
   // the axis vector is the difference 
   const TruncatedPyramid* pyr 
     = dynamic_cast< const TruncatedPyramid* > (thisCell);    
   if( pyr ) {
     axis.SetCoordinates( pyr->getPosition(1).x(), 
              pyr->getPosition(1).y(), 
              pyr->getPosition(1).z() ); 
     
     math::XYZVector axis0( pyr->getPosition(0).x(), 
                pyr->getPosition(0).y(), 
                pyr->getPosition(0).z() );
     
     axis -= axis0;    
   }
   else return 0;
 
 //   if( !geomfound ) {
 //     LogError("PFRecHitProducerECAL")<<"cannor find geometry for detid "
 //               <<detid.rawId()<<" in layer "<<layer<<endl;
 //     return 0; // geometry not found, skip rechit
 //   }
   
   
   reco::PFRecHit *rh 
     = new reco::PFRecHit( detid.rawId(), layer, 
               energy, 
               position.x(), position.y(), position.z(), 
               axis.x(), axis.y(), axis.z() ); 
 
 
   const CaloCellGeometry::CornersVec& corners = thisCell->getCorners();
   assert( corners.size() == 8 );
 
   rh->setNECorner( corners[0].x(), corners[0].y(),  corners[0].z() );
   rh->setSECorner( corners[1].x(), corners[1].y(),  corners[1].z() );
   rh->setSWCorner( corners[2].x(), corners[2].y(),  corners[2].z() );
   rh->setNWCorner( corners[3].x(), corners[3].y(),  corners[3].z() );
 
   return rh;
 }

void PFRecHitProducerECAL::createRecHits	(	std::vector< reco::PFRecHit > &	rechits,
		std::vector< reco::PFRecHit > &	rechitsCleaned,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

gets ecal barrel and endcap rechits, translate them to PFRecHits, which are stored in the rechits vector

Implements PFRecHitProducer.

Definition at line 72 of file PFRecHitProducerECAL.cc.

References createEcalRecHit(), CaloRecHit::detid(), cond::rpcobgas::detid, DetId::Ecal, PFLayer::ECAL_BARREL, PFLayer::ECAL_ENDCAP, EcalBarrel, EcalEndcap, ecalNeighbArray(), CaloRecHit::energy(), relval_parameters_module::energy, edm::hlt::Exception, findRecHitNeighboursECAL(), newFWLiteAna::found, edm::EventSetup::get(), edm::Event::getByLabel(), i, inputTagEcalRecHitsEB_, inputTagEcalRecHitsEE_, edm::HandleBase::isValid(), EcalRecHit::kOutOfTime, EcalRecHit::kTowerRecovered, neighbourmapcalculated_, DetId::rawId(), EcalRecHit::recoFlag(), reco::PFRecHit::setRescale(), DetId::subdetId(), PFRecHitProducer::thresh_Barrel_, PFRecHitProducer::thresh_Endcap_, threshCleaning_, CaloRecHit::time(), cond::rpcobgas::time, and timingCleaning_.

                                                   {
 
 
 
   // this map is necessary to find the rechit neighbours efficiently
   //C but I should think about using Florian's hashed index to do this.
   //C in which case the map might not be necessary anymore
   // 
   // the key of this map is detId. 
   // the value is the index in the rechits vector
   map<unsigned, unsigned > idSortedRecHits;
 //   typedef map<unsigned, unsigned >::iterator IDH;
 
   edm::ESHandle<CaloGeometry> geoHandle;
   iSetup.get<CaloGeometryRecord>().get(geoHandle);
   
   // get the ecalBarrel geometry
   const CaloSubdetectorGeometry *ebtmp = 
     geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
   
   const EcalBarrelGeometry* ecalBarrelGeometry = 
     dynamic_cast< const EcalBarrelGeometry* > (ebtmp);
   assert( ecalBarrelGeometry );
 
   // get the ecalBarrel topology
   EcalBarrelTopology ecalBarrelTopology(geoHandle);
 
   // get the endcap geometry
   const CaloSubdetectorGeometry *eetmp = 
     geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
 
   const EcalEndcapGeometry* ecalEndcapGeometry = 
     dynamic_cast< const EcalEndcapGeometry* > (eetmp);
   assert( ecalEndcapGeometry );
   
 
   // get the endcap topology
   EcalEndcapTopology ecalEndcapTopology(geoHandle);
 
     
   if(!neighbourmapcalculated_)
     ecalNeighbArray( *ecalBarrelGeometry,
              ecalBarrelTopology,
              *ecalEndcapGeometry,
              ecalEndcapTopology );
 
          
   // get the ecalBarrel rechits
 
   edm::Handle<EcalRecHitCollection> rhcHandle;
 
 
   bool found = iEvent.getByLabel(inputTagEcalRecHitsEB_, 
                  rhcHandle);
   
   if(!found) {
 
     ostringstream err;
     err<<"could not find rechits "<<inputTagEcalRecHitsEB_;
     LogError("PFRecHitProducerECAL")<<err.str()<<endl;
     
     throw cms::Exception( "MissingProduct", err.str());
   }
   else {
     assert( rhcHandle.isValid() );
     
     // process ecal ecalBarrel rechits
     for(unsigned i=0; i<rhcHandle->size(); i++) {
       
       const EcalRecHit& erh = (*rhcHandle)[i];
       const DetId& detid = erh.detid();
       double energy = erh.energy();
       uint32_t flag = erh.recoFlag();
       double time = erh.time();
 
       EcalSubdetector esd=(EcalSubdetector)detid.subdetId();
       if (esd != 1) continue;
 
       if(energy < thresh_Barrel_ ) continue;
           
       // Check and skip the TT recovered rechits
       if ( flag == EcalRecHit::kTowerRecovered ) { 
     // std::cout << "Rechit was recovered with energy " << energy << std::endl;
     continue;
       }
 
       // Just clean ECAL Barrel rechits out of time by more than 5 sigma.
       if ( timingCleaning_ && energy > threshCleaning_ && flag == EcalRecHit::kOutOfTime ) { 
     reco::PFRecHit *pfrhCleaned = createEcalRecHit(detid, energy,  
                                PFLayer::ECAL_BARREL,
                                ecalBarrelGeometry);
     if( !pfrhCleaned ) continue; // problem with this rechit. skip it      
     pfrhCleaned->setRescale(time);
     rechitsCleaned.push_back( *pfrhCleaned );
     delete pfrhCleaned;
     continue;
       } 
 
       
       reco::PFRecHit *pfrh = createEcalRecHit(detid, energy,  
                           PFLayer::ECAL_BARREL,
                           ecalBarrelGeometry);
       
       if( !pfrh ) continue; // problem with this rechit. skip it
       pfrh->setRescale(time);
       
       rechits.push_back( *pfrh );
       delete pfrh;
       idSortedRecHits.insert( make_pair(detid.rawId(), rechits.size()-1 ) ); 
     }      
   }
 
 
 
   //C proceed as for the barrel
   // process ecal endcap rechits
 
   found = iEvent.getByLabel(inputTagEcalRecHitsEE_,
                 rhcHandle);
   
   if(!found) {
     ostringstream err;
     err<<"could not find rechits "<<inputTagEcalRecHitsEE_;
     LogError("PFRecHitProducerECAL")<<err.str()<<endl;
     
     throw cms::Exception( "MissingProduct", err.str());
   }
   else {
     assert( rhcHandle.isValid() );
     
     for(unsigned i=0; i<rhcHandle->size(); i++) {
       
       const EcalRecHit& erh = (*rhcHandle)[i];
       const DetId& detid = erh.detid();
       double energy = erh.energy();
       uint32_t flag = erh.recoFlag();
       double time = erh.time();
       EcalSubdetector esd=(EcalSubdetector)detid.subdetId();
       if (esd != 2) continue;
       if(energy < thresh_Endcap_ ) continue;
 
       // Check and skip the TT recovered rechits
       if ( flag == EcalRecHit::kTowerRecovered ) { 
     // std::cout << "Rechit was recovered with energy " << energy << std::endl;
     continue;
       }
       
       reco::PFRecHit *pfrh = createEcalRecHit(detid, energy,
                           PFLayer::ECAL_ENDCAP,
                           ecalEndcapGeometry);
       if( !pfrh ) continue; // problem with this rechit. skip it
       pfrh->setRescale(time);
 
       rechits.push_back( *pfrh );
       delete pfrh;
       idSortedRecHits.insert( make_pair(detid.rawId(), rechits.size()-1 ) ); 
     }
   }
 
 
   // do navigation
   for(unsigned i=0; i<rechits.size(); i++ ) {
     
 //     findRecHitNeighbours( rechits[i], idSortedRecHits, 
 //            ecalBarrelTopology, 
 //            *ecalBarrelGeometry, 
 //            ecalEndcapTopology,
 //            *ecalEndcapGeometry);
     findRecHitNeighboursECAL( rechits[i], idSortedRecHits ); 
                   
   }
 } 

void PFRecHitProducerECAL::ecalNeighbArray	(	const EcalBarrelGeometry &	barrelGeom,
		const CaloSubdetectorTopology &	barrelTopo,
		const EcalEndcapGeometry &	endcapGeom,
		const CaloSubdetectorTopology &	endcapTopo
	)

private

fill the vectors neighboursEB_ and neighboursEE_ which keep track of the neighbours of each rechit. to be called at the beginning of the run

Definition at line 422 of file PFRecHitProducerECAL.cc.

References EAST, DetId::Ecal, EcalBarrel, EcalEndcap, CaloSubdetectorGeometry::getValidDetIds(), CaloSubdetectorTopology::getWindow(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), recoMuon::in, LogDebug, neighbourmapcalculated_, neighboursEB_, neighboursEE_, NORTH, NORTHEAST, NORTHWEST, findQualityFiles::size, SOUTH, SOUTHEAST, SOUTHWEST, ntuplemaker::status, stdmove(), and WEST.

Referenced by createRecHits().

                                                              {
   
 
   static const CaloDirection orderedDir[8]={SOUTHWEST,
                         SOUTH,
                         SOUTHEAST,
                         WEST,
                         EAST,
                         NORTHWEST,
                         NORTH,
                                             NORTHEAST};
 
   const unsigned nbarrel = 62000;
   // Barrel first. The hashed index runs from 0 to 61199
   neighboursEB_.resize(nbarrel);
   
   //std::cout << " Building the array of neighbours (barrel) " ;
 
   const std::vector<DetId>& vec(barrelGeom.getValidDetIds(DetId::Ecal,
                               EcalBarrel));
   unsigned size=vec.size();    
   for(unsigned ic=0; ic<size; ++ic) 
     {
       // We get the 9 cells in a square. 
       std::vector<DetId> neighbours(barrelTopo.getWindow(vec[ic],3,3));
       //      std::cout << " Cell " << EBDetId(vec[ic]) << std::endl;
       unsigned nneighbours=neighbours.size();
 
       unsigned hashedindex=EBDetId(vec[ic]).hashedIndex();
       if(hashedindex>=nbarrel)
         {
           LogDebug("CaloGeometryTools")  << " Array overflow " << std::endl;
         }
 
 
       // If there are 9 cells, it is easy, and this order is know:
 //      6  7  8
 //      3  4  5 
 //      0  1  2   (0 = SOUTHWEST)
 
       if(nneighbours==9)
         {
           neighboursEB_[hashedindex].reserve(8);
           for(unsigned in=0;in<nneighbours;++in)
             {
               // remove the centre
               if(neighbours[in]!=vec[ic]) 
                 {
                   neighboursEB_[hashedindex].push_back(neighbours[in]);
                   //          std::cout << " Neighbour " << in << " " << EBDetId(neighbours[in]) << std::endl;
                 }
             }
         }
       else
         {
           DetId central(vec[ic]);
           neighboursEB_[hashedindex].resize(8,DetId(0));
           for(unsigned idir=0;idir<8;++idir)
             {
               DetId testid=central;
               bool status=stdmove(testid,orderedDir[idir],
                   barrelTopo, endcapTopo,
                   barrelGeom, endcapGeom);
               if(status) neighboursEB_[hashedindex][idir]=testid;
             }
 
         }
     }
 
   // Moved to the endcap
 
   //  std::cout << " done " << size << std::endl;
   //  std::cout << " Building the array of neighbours (endcap) " ;
 
 //  vec.clear();
   const std::vector<DetId>& vecee=endcapGeom.getValidDetIds(DetId::Ecal,EcalEndcap);
   size=vecee.size();    
   // There are some holes in the hashedIndex for the EE. Hence the array is bigger than the number
   // of crystals
   const unsigned nendcap=19960;
 
   neighboursEE_.resize(nendcap);
   for(unsigned ic=0; ic<size; ++ic) 
     {
       // We get the 9 cells in a square. 
       std::vector<DetId> neighbours(endcapTopo.getWindow(vecee[ic],3,3));
       unsigned nneighbours=neighbours.size();
       // remove the centre
       unsigned hashedindex=EEDetId(vecee[ic]).hashedIndex();
       
       if(hashedindex>=nendcap)
         {
           LogDebug("CaloGeometryTools")  << " Array overflow " << std::endl;
         }
 
       if(nneighbours==9)
         {
           neighboursEE_[hashedindex].reserve(8);
           for(unsigned in=0;in<nneighbours;++in)
             {     
               // remove the centre
               if(neighbours[in]!=vecee[ic]) 
                 {
                   neighboursEE_[hashedindex].push_back(neighbours[in]);
                 }
             }
         }
       else
         {
           DetId central(vecee[ic]);
           neighboursEE_[hashedindex].resize(8,DetId(0));
           for(unsigned idir=0;idir<8;++idir)
             {
               DetId testid=central;
               bool status=stdmove(testid,orderedDir[idir],
                   barrelTopo, endcapTopo,
                   barrelGeom, endcapGeom);
 
               if(status) neighboursEE_[hashedindex][idir]=testid;
             }
 
         }
     }
   //  std::cout << " done " << size <<std::endl;
   neighbourmapcalculated_ = true;
 }

bool PFRecHitProducerECAL::findEcalRecHitGeometry	(	const DetId &	detid,
		const CaloSubdetectorGeometry *	geom,
		math::XYZVector &	position,
		math::XYZVector &	axis
	)

private

find the position and the axis of the cell for a given rechit

Definition at line 322 of file PFRecHitProducerECAL.cc.

References CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), TruncatedPyramid::getPosition(), DetId::rawId(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                             {
   
 
   const CaloCellGeometry *thisCell 
     = geom->getGeometry(detid);
   
   // find rechit geometry
   if(!thisCell) {
     LogError("PFRecHitProducerECAL")
       <<"warning detid "<<detid.rawId()
       <<" not found in geometry"<<endl;
     return false;
   }
   
   position.SetCoordinates ( thisCell->getPosition().x(),
                 thisCell->getPosition().y(),
                 thisCell->getPosition().z() );
 
   
   
   // the axis vector is the difference 
   const TruncatedPyramid* pyr 
     = dynamic_cast< const TruncatedPyramid* > (thisCell);    
   if( pyr ) {
     axis.SetCoordinates( pyr->getPosition(1).x(), 
              pyr->getPosition(1).y(), 
              pyr->getPosition(1).z() ); 
     
     math::XYZVector axis0( pyr->getPosition(0).x(), 
                pyr->getPosition(0).y(), 
                pyr->getPosition(0).z() );
     
     axis -= axis0;
 
     
     return true;
   }
   else return false;
 }

void PFRecHitProducerECAL::findRecHitNeighboursECAL	(	reco::PFRecHit &	rh,
		const std::map< unsigned, unsigned > &	sortedHits
	)

private

find rechit neighbours, using the hashed index

Definition at line 369 of file PFRecHitProducerECAL.cc.

References reco::PFRecHit::add4Neighbour(), reco::PFRecHit::add8Neighbour(), reco::PFRecHit::detId(), EAST, i, NORTH, NORTHEAST, NORTHWEST, DetId::rawId(), SOUTH, SOUTHEAST, SOUTHWEST, and WEST.

Referenced by createRecHits().

                                               {
   
   DetId center( rh.detId() );
 
 
   DetId north = move( center, NORTH );
   DetId northeast = move( center, NORTHEAST );
   DetId northwest = move( center, NORTHWEST ); 
   DetId south = move( center, SOUTH );  
   DetId southeast = move( center, SOUTHEAST );  
   DetId southwest = move( center, SOUTHWEST );  
   DetId east  = move( center, EAST );  
   DetId west  = move( center, WEST );  
     
   IDH i = sortedHits.find( north.rawId() );
   if(i != sortedHits.end() ) 
     rh.add4Neighbour( i->second );
   
   i = sortedHits.find( northeast.rawId() );
   if(i != sortedHits.end() ) 
     rh.add8Neighbour( i->second );
   
   i = sortedHits.find( south.rawId() );
   if(i != sortedHits.end() ) 
     rh.add4Neighbour( i->second );
     
   i = sortedHits.find( southwest.rawId() );
   if(i != sortedHits.end() ) 
     rh.add8Neighbour( i->second );
     
   i = sortedHits.find( east.rawId() );
   if(i != sortedHits.end() ) 
     rh.add4Neighbour( i->second );
     
   i = sortedHits.find( southeast.rawId() );
   if(i != sortedHits.end() ) 
     rh.add8Neighbour( i->second );
     
   i = sortedHits.find( west.rawId() );
   if(i != sortedHits.end() ) 
      rh.add4Neighbour( i->second );
    
   i = sortedHits.find( northwest.rawId() );
   if(i != sortedHits.end() ) 
     rh.add8Neighbour( i->second );
 }

DetId PFRecHitProducerECAL::move	(	DetId	cell,
		const CaloDirection &	dir
	)		const

private

Definition at line 727 of file PFRecHitProducerECAL.cc.

References dir, EcalBarrel, EBDetId::hashedIndex(), EEDetId::hashedIndex(), neighbourmapcalculated_, neighboursEB_, neighboursEE_, NONE, query::result, and DetId::subdetId().

Referenced by python.Vispa.Gui.WidgetContainer.WidgetContainer::autosize(), and python.Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

 {  
   DetId originalcell = cell; 
   if(dir==NONE || cell==DetId(0)) return false;
 
   // Conversion CaloDirection and index in the table
   // CaloDirection :NONE,SOUTH,SOUTHEAST,SOUTHWEST,EAST,WEST, NORTHEAST,NORTHWEST,NORTH
   // Table : SOUTHWEST,SOUTH,SOUTHEAST,WEST,EAST,NORTHWEST,NORTH, NORTHEAST
   static const int calodirections[9]={-1,1,2,0,4,3,7,5,6};
     
   assert(neighbourmapcalculated_);
 
   DetId result = (originalcell.subdetId()==EcalBarrel) ? 
     neighboursEB_[EBDetId(originalcell).hashedIndex()][calodirections[dir]]:
     neighboursEE_[EEDetId(originalcell).hashedIndex()][calodirections[dir]];
   return result; 
 }

bool PFRecHitProducerECAL::stdmove	(	DetId &	cell,
		const CaloDirection &	dir,
		const CaloSubdetectorTopology &	barrelTopo,
		const CaloSubdetectorTopology &	endcapTopo,
		const EcalBarrelGeometry &	barrelGeom,
		const EcalEndcapGeometry &	endcapGeom
	)		const

private

Definition at line 634 of file PFRecHitProducerECAL.cc.

References EAST, NORTH, NORTHEAST, NORTHWEST, query::result, SOUTH, SOUTHEAST, SOUTHWEST, stdsimplemove(), and WEST.

Referenced by ecalNeighbArray().

         {
 
 
   bool result; 
 
   if(dir==NORTH) {
     result = stdsimplemove(cell,NORTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
     return result;
   }
   else if(dir==SOUTH) {
     result = stdsimplemove(cell,SOUTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
     return result;
   }
   else if(dir==EAST) {
     result = stdsimplemove(cell,EAST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
     return result;
   }
   else if(dir==WEST) {
     result = stdsimplemove(cell,WEST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
     return result;
   }
 
 
   // One has to try both paths
   else if(dir==NORTHEAST)
     {
       result = stdsimplemove(cell,NORTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
       if(result)
         return stdsimplemove(cell,EAST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
       else
         {
           result = stdsimplemove(cell,EAST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
           if(result)
             return stdsimplemove(cell,NORTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
           else
             return false; 
         }
     }
   else if(dir==NORTHWEST)
     {
       result = stdsimplemove(cell,NORTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
       if(result)
         return stdsimplemove(cell,WEST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
       else
         {
           result = stdsimplemove(cell,WEST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
           if(result)
             return stdsimplemove(cell,NORTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
           else
             return false; 
         }
     }
   else if(dir == SOUTHEAST)
     {
       result = stdsimplemove(cell,SOUTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
       if(result)
         return stdsimplemove(cell,EAST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
       else
         {
           result = stdsimplemove(cell,EAST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
           if(result)
             return stdsimplemove(cell,SOUTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
           else
             return false; 
         }
     }
   else if(dir == SOUTHWEST)
     {
       result = stdsimplemove(cell,SOUTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
       if(result)
         return stdsimplemove(cell,WEST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
       else
         {
           result = stdsimplemove(cell,SOUTH, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
           if(result)
             return stdsimplemove(cell,WEST, barrelTopo, endcapTopo, barrelGeom, endcapGeom );
           else
             return false; 
         }
     }
   cell = DetId(0);
   return false;
 }

bool PFRecHitProducerECAL::stdsimplemove	(	DetId &	cell,
		const CaloDirection &	dir,
		const CaloSubdetectorTopology &	barrelTopo,
		const CaloSubdetectorTopology &	endcapTopo,
		const EcalBarrelGeometry &	barrelGeom,
		const EcalEndcapGeometry &	endcapGeom
	)		const

private

Definition at line 556 of file PFRecHitProducerECAL.cc.

References crossBarrelEndcapBorder_, EcalBarrel, EcalEndcap, EcalEndcapGeometry::getClosestBarrelCells(), EcalBarrelGeometry::getClosestEndcapCells(), CaloSubdetectorTopology::getNeighbours(), EBDetId::ietaAbs(), EEDetId::iPhiOuterRing(), EBDetId::MAX_IETA, and DetId::subdetId().

Referenced by stdmove().

         {
 
   std::vector<DetId> neighbours;
 
   // BARREL CASE 
   if(cell.subdetId()==EcalBarrel) {
     EBDetId ebDetId = cell;
 
     neighbours = barrelTopo.getNeighbours(ebDetId,dir);
 
     // first try to move according to the standard navigation
     if(neighbours.size()>0 && !neighbours[0].null()) {
       cell = neighbours[0];
       return true;
     }
 
     // failed.
 
     if(crossBarrelEndcapBorder_) {
       // are we on the outer ring ?
       const int ietaAbs ( ebDetId.ietaAbs() ) ; // abs value of ieta
       if( EBDetId::MAX_IETA == ietaAbs ) {
     // get ee nbrs for for end of barrel crystals  
     
     // yes we are
     const EcalBarrelGeometry::OrderedListOfEEDetId& 
       ol( * barrelGeom.getClosestEndcapCells( ebDetId ) ) ;
     
     // take closest neighbour on the other side, that is in the barrel.
     cell = *(ol.begin() );
     return true;
       }   
     }
   }
 
   // ENDCAP CASE 
   else if(cell.subdetId()==EcalEndcap) {
 
     EEDetId eeDetId = cell;
 
     neighbours= endcapTopo.getNeighbours(eeDetId,dir);
 
     if(neighbours.size()>0 && !neighbours[0].null()) {
       cell = neighbours[0];
       return true;
     }
 
     // failed.
 
     if(crossBarrelEndcapBorder_) {
       // are we on the outer ring ?
       const int iphi ( eeDetId.iPhiOuterRing() ) ;    
       if( iphi!= 0) {
     // yes we are
     const EcalEndcapGeometry::OrderedListOfEBDetId& 
       ol( * endcapGeom.getClosestBarrelCells( eeDetId ) ) ;
     
     // take closest neighbour on the other side, that is in the barrel.
     cell = *(ol.begin() );
     return true;
       }   
     }
   } 
 
   // everything failed 
   cell = DetId(0);
   return false;
 }