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) override
	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
virtual	~SeedFinderBase ()=default

Private Types
typedef std::tuple< std::vector< int >, std::vector< double >, std::vector< double > >	I3tuple

Private Attributes
const std::unordered_map< std::string, int >	_layerMap
const int	_nNeighbours
std::array< I3tuple, 35 >	_thresholds

Static Private Attributes
static int	layerOffset = 15

Detailed Description

Definition at line 9 of file LocalMaximumSeedFinder.h.

Member Typedef Documentation

typedef std::tuple<std::vector<int>, std::vector<double> , std::vector<double> > LocalMaximumSeedFinder::I3tuple

private

Definition at line 24 of file LocalMaximumSeedFinder.h.

Constructor & Destructor Documentation

LocalMaximumSeedFinder::LocalMaximumSeedFinder

(

const edm::ParameterSet &

conf

)

Definition at line 14 of file LocalMaximumSeedFinder.cc.

References _layerMap, _thresholds, particleFlowClusterHBHE_cfi::depths, PFLayer::ECAL_BARREL, PFLayer::ECAL_ENDCAP, mps_splice::entry, Exception, findSeeds(), PFLayer::HCAL_BARREL1, PFLayer::HCAL_BARREL2, PFLayer::HCAL_ENDCAP, PFLayer::HF_EM, PFLayer::HF_HAD, mps_fire::i, createfilelist::int, layerOffset, PFLayer::NONE, PFLayer::PS1, PFLayer::PS2, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, and particleFlowZeroSuppressionECAL_cff::thresholds.

                                                    : 
  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", 19}, 
          {"HCAL_ENDCAP",(int)PFLayer::HCAL_ENDCAP},
          {"HF_EM",(int)PFLayer::HF_EM},
          {"HF_HAD",(int)PFLayer::HF_HAD} }) {
  const std::vector<edm::ParameterSet>& thresholds =
    conf.getParameterSetVector("thresholdsByDetector");
  for( const auto& pset : thresholds ) {
    const std::string& det = pset.getParameter<std::string>("detector");

    std::vector<int> depths;
    std::vector<double> thresh_E;
    std::vector<double> thresh_pT ;
    std::vector<double> thresh_pT2;

    if (det==std::string("HCAL_BARREL1") || det==std::string("HCAL_ENDCAP")) {
      depths = pset.getParameter<std::vector<int> >("depths");
      thresh_E = pset.getParameter<std::vector<double> >("seedingThreshold");
      thresh_pT = pset.getParameter<std::vector<double> >("seedingThresholdPt");
      if(thresh_E.size()!=depths.size() || thresh_pT.size()!=depths.size()) {
    throw cms::Exception("InvalidGatheringThreshold")
      << "gatheringThresholds mismatch with the numbers of depths";
      }
    } else {
      depths.push_back(0);
      thresh_E.push_back(pset.getParameter<double>("seedingThreshold"));
      thresh_pT.push_back(pset.getParameter<double>("seedingThresholdPt"));
    }

    for(unsigned int i=0;i < thresh_pT.size();++i){
      thresh_pT2.push_back(thresh_pT[i]*thresh_pT[i]);
    }

    auto entry = _layerMap.find(det);
    if( entry == _layerMap.end() ) {
      throw cms::Exception("InvalidDetectorLayer")
    << "Detector layer : " << det << " is not in the list of recognized"
    << " detector layers!";
    }

    _thresholds[entry->second+layerOffset]= 
      std::make_tuple(depths,thresh_E,thresh_pT2);
  }
}

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  )

overridevirtual

Implements SeedFinderBase.

Definition at line 71 of file LocalMaximumSeedFinder.cc.

References _nNeighbours, _thresholds, funct::abs(), KineDebug3::count(), declareDynArray, egammaForCoreTracking_cff::depth, Exception, PFLayer::HCAL_BARREL1, PFLayer::HCAL_BARREL2, PFLayer::HCAL_ENDCAP, mps_fire::i, training_settings::idx, initDynArray, createfilelist::int, layerOffset, LogDebug, eostools::move(), nhits, particleFlowZeroSuppressionECAL_cff::thresholds, and unInitDynArray.

Referenced by LocalMaximumSeedFinder().

                                   {

  auto nhits = input->size();
  initDynArray(bool,nhits,usable,true);
  //need to run over energy sorted rechits
  declareDynArray(float,nhits,energies);
  unInitDynArray(int,nhits,qst); // queue storage
  auto cmp = [&](int i, int j) { return energies[i] < energies[j]; };
  std::priority_queue<int, DynArray<int>, decltype(cmp)> ordered_hits(cmp,std::move(qst));

  for( unsigned i = 0; i < nhits; ++i ) {
    if( !mask[i] ) continue; // cannot seed masked objects
    auto const & maybeseed = (*input)[i];
    energies[i]=maybeseed.energy();
    int seedlayer = (int)maybeseed.layer();
    if( seedlayer == PFLayer::HCAL_BARREL2 &&
        std::abs(maybeseed.positionREP().eta()) > 0.34 ) {
      seedlayer = 19;
    }
    auto const & thresholds = _thresholds[seedlayer+layerOffset];


    double thresholdE=0.;
    double thresholdPT2=0.;

    for (unsigned int j=0; j<(std::get<2>(thresholds)).size(); ++j) {

      int depth=std::get<0>(thresholds)[j];
      if( ( seedlayer == PFLayer::HCAL_BARREL1 && maybeseed.depth()== depth)
      || ( seedlayer == PFLayer::HCAL_ENDCAP && maybeseed.depth()== depth)
      || ( seedlayer != PFLayer::HCAL_BARREL1 && seedlayer != PFLayer::HCAL_ENDCAP)
      ) { thresholdE=std::get<1>(thresholds)[j]; thresholdPT2=std::get<2>(thresholds)[j]; }

    }

    if( maybeseed.energy() < thresholdE ||
    maybeseed.pt2() < thresholdPT2   ) usable[i] = false;
    if( !usable[i] ) continue;
    ordered_hits.push(i);

  }


  while(!ordered_hits.empty() ) {
    auto idx = ordered_hits.top();
    ordered_hits.pop();  
    if( !usable[idx] ) continue;
    //get the neighbours of this seed
    auto const & maybeseed = (*input)[idx];
    reco::PFRecHit::Neighbours  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( auto neighbour : myNeighbours ) {
      if( !mask[neighbour] ) continue;
      if( energies[neighbour] > energies[idx] ) {
//        std::cout << "how this can be?" << std::endl;
    seedable[idx] = false;  
    break;
      }
    }
    if( seedable[idx] ) {
      for( auto neighbour : myNeighbours ) {
    usable[neighbour] = false;
      }
    }
  }

  LogDebug("LocalMaximumSeedFinder") << " found " << std::count(seedable.begin(),seedable.end(),true) << " seeds";

}

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 LocalMaximumSeedFinder().

const int LocalMaximumSeedFinder::_nNeighbours

private

Definition at line 20 of file LocalMaximumSeedFinder.h.

Referenced by findSeeds().

std::array<I3tuple, 35> LocalMaximumSeedFinder::_thresholds

private

Definition at line 26 of file LocalMaximumSeedFinder.h.

Referenced by findSeeds(), and LocalMaximumSeedFinder().

int LocalMaximumSeedFinder::layerOffset = 15

staticprivate

Definition at line 27 of file LocalMaximumSeedFinder.h.

Referenced by findSeeds(), and LocalMaximumSeedFinder().