PFECALHashNavigator.h

Go to the documentation of this file.

#ifndef RecoParticleFlow_PFClusterProducer_PFECALHashNavigator_h
#define RecoParticleFlow_PFClusterProducer_PFECALHashNavigator_h


#include "RecoParticleFlow/PFClusterProducer/interface/PFRecHitNavigatorBase.h"
#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"

#include "RecoCaloTools/Navigation/interface/CaloNavigator.h"
#include "DataFormats/EcalDetId/interface/EBDetId.h"
#include "DataFormats/EcalDetId/interface/EEDetId.h"

#include "Geometry/CaloTopology/interface/EcalEndcapTopology.h"
#include "Geometry/CaloTopology/interface/EcalBarrelTopology.h"
#include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h"
#include "Geometry/EcalAlgo/interface/EcalBarrelGeometry.h"

  static const CaloDirection orderedDir[8]={SOUTHWEST,
                        SOUTH,
                        SOUTHEAST,
                        WEST,
                        EAST,
                        NORTHWEST,
                        NORTH,
                        NORTHEAST};


class PFECALHashNavigator : public PFRecHitNavigatorBase {
 public:



  PFECALHashNavigator() {

  }



  PFECALHashNavigator(const edm::ParameterSet& iConfig):
    PFRecHitNavigatorBase(iConfig){

  crossBarrelEndcapBorder_ =
    iConfig.getParameter<bool>("crossBarrelEndcapBorder");

  neighbourmapcalculated_ = false;

  }

  void beginEvent(const edm::EventSetup& iSetup) override {
      edm::ESHandle<CaloGeometry> geoHandle;
      iSetup.get<CaloGeometryRecord>().get(geoHandle);
      
      const CaloSubdetectorGeometry *ebTmp = 
    geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
      const CaloSubdetectorGeometry *eeTmp = 
    geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalEndcap);

      barrelGeometry_  = dynamic_cast< const EcalBarrelGeometry* > (ebTmp);
      endcapGeometry_  = dynamic_cast < const EcalEndcapGeometry* > (eeTmp);

      // get the ecalBarrel topology
      barrelTopology_ = std::make_unique<EcalBarrelTopology>(*geoHandle);
      endcapTopology_ = std::make_unique<EcalEndcapTopology>(*geoHandle);

      ecalNeighbArray(*barrelGeometry_,*barrelTopology_,*endcapGeometry_,*endcapTopology_);

  }

  void associateNeighbours(reco::PFRecHit& rh,std::unique_ptr<reco::PFRecHitCollection>& hits,edm::RefProd<reco::PFRecHitCollection>& refprod) override {



  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 );  


  associateNeighbour(north,rh,hits,refprod,0,1,0);
  associateNeighbour(northeast,rh,hits,refprod,1,1,0);
  associateNeighbour(south,rh,hits,refprod,0,-1,0);
  associateNeighbour(southwest,rh,hits,refprod,-1,-1,0);
  associateNeighbour(east,rh,hits,refprod,1,0,0);
  associateNeighbour(southeast,rh,hits,refprod,1,-1,0);
  associateNeighbour(west,rh,hits,refprod,-1,0,0);
  associateNeighbour(northwest,rh,hits,refprod,-1,1,0);

  }








 protected:


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


    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 stdsimplemove(DetId& cell, 
           const CaloDirection& dir,
           const CaloSubdetectorTopology& barrelTopo,
           const CaloSubdetectorTopology& endcapTopo,
           const EcalBarrelGeometry& barrelGeom,
           const EcalEndcapGeometry& endcapGeom ) 
  const {
  
  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.empty() && !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.empty() && !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;
}



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


  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;
}



DetId move(DetId cell, 
       const CaloDirection&dir ) const
{  
  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; 
}


  std::unique_ptr<EcalEndcapTopology> endcapTopology_;
  std::unique_ptr<EcalBarrelTopology> barrelTopology_;

  const EcalEndcapGeometry *endcapGeometry_;
  const EcalBarrelGeometry *barrelGeometry_;

  std::vector<std::vector<DetId> >  neighboursEB_;

  std::vector<std::vector<DetId> >  neighboursEE_;
  
  bool  neighbourmapcalculated_;

  bool  crossBarrelEndcapBorder_;


};





#endif