LocalMaximumSeedFinder Class Reference

#include <LocalMaximumSeedFinder.h>

Inheritance diagram for LocalMaximumSeedFinder:

Public Member Functions
void	findSeeds (const edm::Handle< reco::PFRecHitCollection > &input, const std::vector< bool > &mask, std::vector< bool > &seedable)
	LocalMaximumSeedFinder (const edm::ParameterSet &conf)
	LocalMaximumSeedFinder (const LocalMaximumSeedFinder &)=delete
LocalMaximumSeedFinder &	operator= (const LocalMaximumSeedFinder &)=delete
Public Member Functions inherited from SeedFinderBase
const std::string &	name () const
SeedFinderBase &	operator= (const SeedFinderBase &)=delete
	SeedFinderBase (const edm::ParameterSet &conf)
	SeedFinderBase (const SeedFinderBase &)=delete

Private Attributes
const std::unordered_map < std::string, int >	_layerMap
const int	_nNeighbours
std::unordered_map< int, std::pair< double, double > >	_thresholds

Static Private Attributes
static const reco::PFRecHitRefVector	_noNeighbours

Detailed Description

Definition at line 8 of file LocalMaximumSeedFinder.h.

Constructor & Destructor Documentation

LocalMaximumSeedFinder::LocalMaximumSeedFinder

(

const edm::ParameterSet &

conf

)

Definition at line 13 of file LocalMaximumSeedFinder.cc.

References PFLayer::ECAL_BARREL, PFLayer::ECAL_ENDCAP, edm::ParameterSet::getParameterSetVector(), PFLayer::HCAL_BARREL1, PFLayer::HCAL_BARREL2, PFLayer::HCAL_ENDCAP, PFLayer::HF_EM, PFLayer::HF_HAD, PFLayer::NONE, PFLayer::PS1, and PFLayer::PS2.

                                                    : 
  SeedFinderBase(conf),   
  _nNeighbours(conf.getParameter<int>("nNeighbours")),
  _layerMap({ {"PS2",(int)PFLayer::PS2},
          {"PS1",(int)PFLayer::PS1},
          {"ECAL_ENDCAP",(int)PFLayer::ECAL_ENDCAP},
          {"ECAL_BARREL",(int)PFLayer::ECAL_BARREL},
          {"NONE",(int)PFLayer::NONE},
          {"HCAL_BARREL1",(int)PFLayer::HCAL_BARREL1},
          {"HCAL_BARREL2_RING0",(int)PFLayer::HCAL_BARREL2},
              // hack to deal with ring1 in HO 
          {"HCAL_BARREL2_RING1",100*(int)PFLayer::HCAL_BARREL2}, 
          {"HCAL_ENDCAP",(int)PFLayer::HCAL_ENDCAP},
          {"HF_EM",(int)PFLayer::HF_EM},
          {"HF_HAD",(int)PFLayer::HF_HAD} }) {

LocalMaximumSeedFinder::LocalMaximumSeedFinder ( const LocalMaximumSeedFinder &  )

delete

Member Function Documentation

void LocalMaximumSeedFinder::findSeeds ( const edm::Handle< reco::PFRecHitCollection > &  input, const std::vector< bool > &  mask, std::vector< bool > &  seedable  )

virtual

Implements SeedFinderBase.

Definition at line 48 of file LocalMaximumSeedFinder.cc.

References _nNeighbours, _noNeighbours, _thresholds, funct::abs(), reco::PFRecHit::energy(), Exception, PFLayer::HCAL_BARREL2, i, customizeTrackingMonitorSeedNumber::idx, reco::PFRecHit::layer(), reco::PFRecHit::neighbours(), reco::PFRecHit::neighbours4(), reco::PFRecHit::neighbours8(), reco::PFRecHit::positionREP(), and reco::PFRecHit::pt2().

                                   {
  std::vector<bool> usable(input->size(),true);
  //need to run over energy sorted rechits
  std::vector<std::pair<unsigned,double> > ordered_hits;
  ordered_hits.reserve(input->size());
  for( unsigned i = 0; i < input->size(); ++i ) {
    std::pair<unsigned,double> val = std::make_pair(i,input->at(i).energy());
    auto pos = std::upper_bound(ordered_hits.begin(),ordered_hits.end(),
                val, greaterByEnergy);
    ordered_hits.insert(pos,val);
  }      

  for( const auto& idx_e : ordered_hits ) {    
    const unsigned idx = idx_e.first;    
    if( !mask[idx] ) continue; // cannot seed masked objects
    const reco::PFRecHit& maybeseed = input->at(idx);
    int seedlayer = (int)maybeseed.layer();
    if( seedlayer == PFLayer::HCAL_BARREL2 && 
    std::abs(maybeseed.positionREP().eta()) > 0.34 ) {
      seedlayer *= 100;
    }    
    const std::pair<double,double>& thresholds =
      _thresholds.find(seedlayer)->second;
    if( maybeseed.energy() < thresholds.first || 
    maybeseed.pt2() < thresholds.second   ) usable[idx] = false;      
    if( !usable[idx] ) continue;
    //get the neighbours of this seed
    const reco::PFRecHitRefVector* myNeighbours;
    switch( _nNeighbours ) {
    case -1:
      myNeighbours = &maybeseed.neighbours();
      break;
    case 0: // for HF clustering
      myNeighbours = &_noNeighbours;
      break;
    case 4:
      myNeighbours = &maybeseed.neighbours4();
      break;
    case 8:
      myNeighbours = &maybeseed.neighbours8();
      break;
    default:
      throw cms::Exception("InvalidConfiguration")
    << "LocalMaximumSeedFinder only accepts nNeighbors = {-1,0,4,8}";    
    }
    seedable[idx] = true;
    for( const reco::PFRecHitRef& neighbour : *myNeighbours ) {
      if( !mask[neighbour.key()] ) continue;
      if( neighbour->energy() > maybeseed.energy() ) {
    seedable[idx] = false;  
    break;
      }
    }
    if( seedable[idx] ) {
      for( const reco::PFRecHitRef& neighbour : *myNeighbours ) {
    usable[neighbour.key()] = false;
      }
    }
  }
}

LocalMaximumSeedFinder& LocalMaximumSeedFinder::operator= ( const LocalMaximumSeedFinder &  )

delete

Member Data Documentation

const std::unordered_map<std::string,int> LocalMaximumSeedFinder::_layerMap

private

Definition at line 22 of file LocalMaximumSeedFinder.h.

Referenced by for().

const int LocalMaximumSeedFinder::_nNeighbours

private

Definition at line 19 of file LocalMaximumSeedFinder.h.

Referenced by findSeeds().

const reco::PFRecHitRefVector LocalMaximumSeedFinder::_noNeighbours

staticprivate

Definition at line 21 of file LocalMaximumSeedFinder.h.

Referenced by findSeeds().

std::unordered_map<int,std::pair<double,double> > LocalMaximumSeedFinder::_thresholds

private

Definition at line 24 of file LocalMaximumSeedFinder.h.

Referenced by findSeeds(), and for().