PFECALHashNavigator Class Reference

#include <PFECALHashNavigator.h>

Inheritance diagram for PFECALHashNavigator:

Public Member Functions
void	associateNeighbours (reco::PFRecHit &rh, std::unique_ptr< reco::PFRecHitCollection > &hits, edm::RefProd< reco::PFRecHitCollection > &refprod) override
void	init (const edm::EventSetup &iSetup) override
	PFECALHashNavigator ()
	PFECALHashNavigator (const edm::ParameterSet &iConfig, edm::ConsumesCollector &cc)
Public Member Functions inherited from PFRecHitNavigatorBase
	PFRecHitNavigatorBase ()=default
	PFRecHitNavigatorBase (const edm::ParameterSet &iConfig, edm::ConsumesCollector &cc)
virtual	~PFRecHitNavigatorBase ()=default

Protected Member Functions
void	ecalNeighbArray (const EcalBarrelGeometry &barrelGeom, const CaloSubdetectorTopology &barrelTopo, const EcalEndcapGeometry &endcapGeom, const CaloSubdetectorTopology &endcapTopo)
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
Protected Member Functions inherited from PFRecHitNavigatorBase
void	associateNeighbour (const DetId &id, reco::PFRecHit &hit, std::unique_ptr< reco::PFRecHitCollection > &hits, edm::RefProd< reco::PFRecHitCollection > &refProd, short eta, short phi, short depth)

Protected Attributes
const EcalBarrelGeometry *	barrelGeometry_
std::unique_ptr< EcalBarrelTopology >	barrelTopology_
bool	crossBarrelEndcapBorder_
	if true, navigation will cross the barrel-endcap border More...
const EcalEndcapGeometry *	endcapGeometry_
std::unique_ptr< EcalEndcapTopology >	endcapTopology_
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...

Private Attributes
edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomToken_

Additional Inherited Members
Public Types inherited from PFRecHitNavigatorBase
typedef std::unordered_map< unsigned, unsigned >	DetIdToHitIdx

Detailed Description

Definition at line 20 of file PFECALHashNavigator.h.

Constructor & Destructor Documentation

PFECALHashNavigator() [1/2]

PFECALHashNavigator::PFECALHashNavigator ( )

inline

Definition at line 22 of file PFECALHashNavigator.h.

{}

PFECALHashNavigator() [2/2]

PFECALHashNavigator::PFECALHashNavigator ( const edm::ParameterSet &  iConfig, edm::ConsumesCollector &  cc  )

inline

Definition at line 24 of file PFECALHashNavigator.h.

      : PFRecHitNavigatorBase(iConfig, cc),
        neighbourmapcalculated_(false),
        crossBarrelEndcapBorder_(iConfig.getParameter<bool>("crossBarrelEndcapBorder")),
        geomToken_(cc.esConsumes<edm::Transition::BeginRun>()) {}

Member Function Documentation

associateNeighbours()

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

inlineoverridevirtual

Implements PFRecHitNavigatorBase.

Definition at line 46 of file PFECALHashNavigator.h.

References PFRecHitNavigatorBase::associateNeighbour(), reco::PFRecHit::detId(), EAST, east, hfClusterShapes_cfi::hits, move(), NORTH, north, NORTHEAST, NORTHWEST, SOUTH, south, SOUTHEAST, SOUTHWEST, WEST, and west.

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

ecalNeighbArray()

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

inlineprotected

Definition at line 71 of file PFECALHashNavigator.h.

References central, DetId::Ecal, EcalBarrel, EcalEndcap, CaloSubdetectorGeometry::getValidDetIds(), CaloSubdetectorTopology::getWindow(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), recoMuon::in, LogDebug, neighbourmapcalculated_, neighboursEB_, neighboursEE_, orderedDir, findQualityFiles::size, mps_update::status, and stdmove().

Referenced by init().

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

init()

void PFECALHashNavigator::init ( const edm::EventSetup &  iSetup )

inlineoverridevirtual

Implements PFRecHitNavigatorBase.

Definition at line 30 of file PFECALHashNavigator.h.

References barrelGeometry_, barrelTopology_, DetId::Ecal, EcalBarrel, EcalEndcap, ecalNeighbArray(), endcapGeometry_, endcapTopology_, geomToken_, edm::EventSetup::getHandle(), and CaloGeometry::getSubdetectorGeometry().

                                                  {
    edm::ESHandle<CaloGeometry> geoHandle = iSetup.getHandle(geomToken_);

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

move()

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

inlineprotected

Definition at line 312 of file PFECALHashNavigator.h.

References cms::cuda::assert(), DeadROC_duringRun::dir, EcalBarrel, EBDetId::hashedIndex(), EEDetId::hashedIndex(), neighbourmapcalculated_, neighboursEB_, neighboursEE_, NONE, mps_fire::result, and DetId::subdetId().

Referenced by associateNeighbours().

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

stdmove()

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

inlineprotected

Definition at line 238 of file PFECALHashNavigator.h.

References DeadROC_duringRun::dir, EAST, NORTH, NORTHEAST, NORTHWEST, mps_fire::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;
  }

stdsimplemove()

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

inlineprotected

Definition at line 168 of file PFECALHashNavigator.h.

References crossBarrelEndcapBorder_, DeadROC_duringRun::dir, EcalBarrel, EcalEndcap, EcalEndcapGeometry::getClosestBarrelCells(), EcalBarrelGeometry::getClosestEndcapCells(), CaloSubdetectorTopology::getNeighbours(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::ietaAbs(), EBDetId::ietaAbs(), hcalRecHitTable_cff::iphi, 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.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;
  }

Member Data Documentation

barrelGeometry_

const EcalBarrelGeometry* PFECALHashNavigator::barrelGeometry_

protected

Definition at line 334 of file PFECALHashNavigator.h.

Referenced by init().

barrelTopology_

std::unique_ptr<EcalBarrelTopology> PFECALHashNavigator::barrelTopology_

protected

Definition at line 331 of file PFECALHashNavigator.h.

Referenced by init().

crossBarrelEndcapBorder_

bool PFECALHashNavigator::crossBarrelEndcapBorder_

protected

if true, navigation will cross the barrel-endcap border

Definition at line 346 of file PFECALHashNavigator.h.

Referenced by stdsimplemove().

endcapGeometry_

const EcalEndcapGeometry* PFECALHashNavigator::endcapGeometry_

protected

Definition at line 333 of file PFECALHashNavigator.h.

Referenced by init().

endcapTopology_

std::unique_ptr<EcalEndcapTopology> PFECALHashNavigator::endcapTopology_

protected

Definition at line 330 of file PFECALHashNavigator.h.

Referenced by init().

geomToken_

edm::ESGetToken<CaloGeometry, CaloGeometryRecord> PFECALHashNavigator::geomToken_

private

Definition at line 349 of file PFECALHashNavigator.h.

Referenced by init().

neighbourmapcalculated_

bool PFECALHashNavigator::neighbourmapcalculated_

protected

set to true in ecalNeighbArray

Definition at line 343 of file PFECALHashNavigator.h.

Referenced by ecalNeighbArray(), and move().

neighboursEB_

std::vector<std::vector<DetId> > PFECALHashNavigator::neighboursEB_

protected

for each ecal barrel rechit, keep track of the neighbours

Definition at line 337 of file PFECALHashNavigator.h.

Referenced by ecalNeighbArray(), and move().

neighboursEE_

std::vector<std::vector<DetId> > PFECALHashNavigator::neighboursEE_

protected

for each ecal endcap rechit, keep track of the neighbours

Definition at line 340 of file PFECALHashNavigator.h.

Referenced by ecalNeighbArray(), and move().