#include <Basic2DGenericPFlowClusterizer.h>

Inheritance diagram for Basic2DGenericPFlowClusterizer:

Public Member Functions
	Basic2DGenericPFlowClusterizer (const edm::ParameterSet &conf)

	Basic2DGenericPFlowClusterizer (const B2DGPF &)=delete

void	buildClusters (const reco::PFClusterCollection &, const std::vector< bool > &, reco::PFClusterCollection &outclus)

B2DGPF &	operator= (const B2DGPF &)=delete

void	update (const edm::EventSetup &es)

virtual	~Basic2DGenericPFlowClusterizer ()

Public Member Functions inherited from PFClusterBuilderBase
std::ostream &	operator<< (std::ostream &o) const

PFCBB &	operator= (const PFCBB &)=delete

	PFClusterBuilderBase (const edm::ParameterSet &conf)

	PFClusterBuilderBase (const PFCBB &)=delete

void	reset ()

	~PFClusterBuilderBase ()

Private Types
typedef Basic2DGenericPFlowClusterizer	B2DGPF

Private Member Functions
void	growPFClusters (const reco::PFCluster &, const std::vector< bool > &, const unsigned toleranceScaling, const unsigned iter, double dist, reco::PFClusterCollection &) const

void	prunePFClusters (reco::PFClusterCollection &) const

void	seedPFClustersFromTopo (const reco::PFCluster &, const std::vector< bool > &, reco::PFClusterCollection &) const

Private Attributes
std::unique_ptr < PFCPositionCalculatorBase >	_allCellsPosCalc

std::unique_ptr < PFCPositionCalculatorBase >	_convergencePosCalc

const bool	_excludeOtherSeeds

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

const unsigned	_maxIterations

const double	_minFracTot

std::unordered_map< int, double >	_recHitEnergyNorms

const double	_showerSigma2

const double	_stoppingTolerance

Additional Inherited Members
Public Types inherited from PFClusterBuilderBase
typedef PFCPositionCalculatorBase	PosCalc

Protected Attributes inherited from PFClusterBuilderBase
const float	_minFractionToKeep

unsigned	_nClustersFound

unsigned	_nSeeds

std::unique_ptr< PosCalc >	_positionCalc

Detailed Description

Definition at line 9 of file Basic2DGenericPFlowClusterizer.h.

Member Typedef Documentation

typedef Basic2DGenericPFlowClusterizer Basic2DGenericPFlowClusterizer::B2DGPF

private

Definition at line 10 of file Basic2DGenericPFlowClusterizer.h.

Constructor & Destructor Documentation

Basic2DGenericPFlowClusterizer::Basic2DGenericPFlowClusterizer ( const edm::ParameterSet & conf )

Definition at line 25 of file Basic2DGenericPFlowClusterizer.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.

                                                             :
     PFClusterBuilderBase(conf),
     _maxIterations(conf.getParameter<unsigned>("maxIterations")),
     _stoppingTolerance(conf.getParameter<double>("stoppingTolerance")),
     _showerSigma2(std::pow(conf.getParameter<double>("showerSigma"),2.0)),
     _excludeOtherSeeds(conf.getParameter<bool>("excludeOtherSeeds")),
     _minFracTot(conf.getParameter<double>("minFracTot")),
     _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},
         {"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} }) { 

virtual Basic2DGenericPFlowClusterizer::~Basic2DGenericPFlowClusterizer ( )

inlinevirtual

Definition at line 14 of file Basic2DGenericPFlowClusterizer.h.

14 {}

Basic2DGenericPFlowClusterizer::Basic2DGenericPFlowClusterizer ( const B2DGPF & )

delete

Member Function Documentation

void Basic2DGenericPFlowClusterizer::buildClusters	(	const reco::PFClusterCollection &	input,
		const std::vector< bool > &	seedable,
		reco::PFClusterCollection &	outclus
	)

virtual

Implements PFClusterBuilderBase.

Definition at line 81 of file Basic2DGenericPFlowClusterizer.cc.

References _allCellsPosCalc, _convergencePosCalc, PFClusterBuilderBase::_positionCalc, growPFClusters(), bookConverter::max, eostools::move(), funct::pow(), prunePFClusters(), and seedPFClustersFromTopo().

                                            {
   reco::PFClusterCollection clustersInTopo;
   for( const auto& topocluster : input ) {
     clustersInTopo.clear();
     seedPFClustersFromTopo(topocluster,seedable,clustersInTopo);
     const unsigned tolScal = 
       std::pow(std::max(1.0,clustersInTopo.size()-1.0),2.0);
     growPFClusters(topocluster,seedable,tolScal,0,tolScal,clustersInTopo);
     // step added by Josh Bendavid, removes low-fraction clusters
     // did not impact position resolution with fraction cut of 1e-7
     // decreases the size of each pf cluster considerably
     prunePFClusters(clustersInTopo);
     // recalculate the positions of the pruned clusters
     if( _convergencePosCalc ) { 
       // if defined, use the special position calculation for convergence tests
       _convergencePosCalc->calculateAndSetPositions(clustersInTopo);
     } else {
       if( clustersInTopo.size() == 1 && _allCellsPosCalc ) {
     _allCellsPosCalc->calculateAndSetPosition(clustersInTopo.back());
       } else {
     _positionCalc->calculateAndSetPositions(clustersInTopo);
       }   
     }
     for( auto& clusterout : clustersInTopo ) {
       output.insert(output.end(),std::move(clusterout));
     }
   }
 }

void Basic2DGenericPFlowClusterizer::growPFClusters	(	const reco::PFCluster &	topo,
		const std::vector< bool > &	seedable,
		const unsigned	toleranceScaling,
		const unsigned	iter,
		double	dist,
		reco::PFClusterCollection &	clusters
	)		const

private

Definition at line 132 of file Basic2DGenericPFlowClusterizer.cc.

References _allCellsPosCalc, _convergencePosCalc, _excludeOtherSeeds, _maxIterations, _minFracTot, PFClusterBuilderBase::_positionCalc, _recHitEnergyNorms, _showerSigma2, _stoppingTolerance, funct::abs(), reco::deltaR2(), diffTreeTool::diff, myMath::fast_expf(), cropTnPTrees::frac, HLT_25ns14e33_v1_cff::fraction, PFLayer::HCAL_BARREL2, i, edm::Ref< C, T, F >::key(), LOGDRESSED, reco::PFCluster::recHitFractions(), and mathSSE::sqrt().

Referenced by buildClusters().

                                                     {
   if( iter >= _maxIterations ) {
     LOGDRESSED("Basic2DGenericPFlowClusterizer:growAndStabilizePFClusters")
       <<"reached " << _maxIterations << " iterations, terminated position "
       << "fit with diff = " << diff;
   }      
   if( iter >= _maxIterations || 
       diff <= _stoppingTolerance*toleranceScaling) return;
   // reset the rechits in this cluster, keeping the previous position    
   std::vector<reco::PFCluster::REPPoint> clus_prev_pos;  
   for( auto& cluster : clusters) {
     const reco::PFCluster::REPPoint& repp = cluster.positionREP();
     clus_prev_pos.emplace_back(repp.rho(),repp.eta(),repp.phi());
     if( _convergencePosCalc ) {
       if( clusters.size() == 1 && _allCellsPosCalc ) {
     _allCellsPosCalc->calculateAndSetPosition(cluster);
       } else {
     _positionCalc->calculateAndSetPosition(cluster);
       }
     }
     cluster.resetHitsAndFractions();
   }
   // loop over topo cluster and grow current PFCluster hypothesis 
   std::vector<double> dist2, frac;
   double fractot = 0, fraction = 0;
   for( const reco::PFRecHitFraction& rhf : topo.recHitFractions() ) {
     const reco::PFRecHitRef& refhit = rhf.recHitRef();
     int cell_layer = (int)refhit->layer();
     if( cell_layer == PFLayer::HCAL_BARREL2 && 
     std::abs(refhit->positionREP().eta()) > 0.34 ) {
       cell_layer *= 100;
     }  
     const double recHitEnergyNorm = 
       _recHitEnergyNorms.find(cell_layer)->second; 
     const math::XYZPoint& topocellpos_xyz = refhit->position();
     dist2.clear(); frac.clear(); fractot = 0;
     // add rechits to clusters, calculating fraction based on distance
     for( auto& cluster : clusters ) {      
       const math::XYZPoint& clusterpos_xyz = cluster.position();
       fraction = 0.0;
       const math::XYZVector deltav = clusterpos_xyz - topocellpos_xyz;
       const double d2 = deltav.Mag2()/_showerSigma2;
       dist2.emplace_back( d2 );
       if( d2 > 100 ) {
     LOGDRESSED("Basic2DGenericPFlowClusterizer:growAndStabilizePFClusters")
       << "Warning! :: pfcluster-topocell distance is too large! d= "
       << d2;
       }
       // fraction assignment logic
       if( refhit->detId() == cluster.seed() && _excludeOtherSeeds ) {
     fraction = 1.0; 
       } else if ( seedable[refhit.key()] && _excludeOtherSeeds ) {
     fraction = 0.0;
       } else {
     fraction = cluster.energy()/recHitEnergyNorm * vdt::fast_expf( -0.5*d2 );
       }      
       fractot += fraction;
       frac.emplace_back(fraction);
     }
     for( unsigned i = 0; i < clusters.size(); ++i ) {      
       if( fractot > _minFracTot || 
       ( refhit->detId() == clusters[i].seed() && fractot > 0.0 ) ) {
     frac[i]/=fractot;
       } else {
     continue;
       }
       // if the fraction has been set to 0, the cell 
       // is now added to the cluster - careful ! (PJ, 19/07/08)
       // BUT KEEP ONLY CLOSE CELLS OTHERWISE MEMORY JUST EXPLOSES
       // (PJ, 15/09/08 <- similar to what existed before the 
       // previous bug fix, but keeps the close seeds inside, 
       // even if their fraction was set to zero.)
       // Also add a protection to keep the seed in the cluster 
       // when the latter gets far from the former. These cases
       // (about 1% of the clusters) need to be studied, as 
       // they create fake photons, in general.
       // (PJ, 16/09/08) 
       if( dist2[i] < 100.0 || frac[i] > 0.9999 ) {  
     clusters[i].addRecHitFraction(reco::PFRecHitFraction(refhit,frac[i]));
       }
     }
   }
   // recalculate positions and calculate convergence parameter
   double diff2 = 0.0;  
   for( unsigned i = 0; i < clusters.size(); ++i ) {
     if( _convergencePosCalc ) {
       _convergencePosCalc->calculateAndSetPosition(clusters[i]);
     } else {
       if( clusters.size() == 1 && _allCellsPosCalc ) {
     _allCellsPosCalc->calculateAndSetPosition(clusters[i]);
       } else {
     _positionCalc->calculateAndSetPosition(clusters[i]);
       }
     }
     const double delta2 = 
       reco::deltaR2(clusters[i].positionREP(),clus_prev_pos[i]);    
     if( delta2 > diff2 ) diff2 = delta2;
   }
   diff = std::sqrt(diff2);
   dist2.clear(); frac.clear(); clus_prev_pos.clear();// avoid badness
   growPFClusters(topo,seedable,toleranceScaling,iter+1,diff,clusters);
 }

B2DGPF& Basic2DGenericPFlowClusterizer::operator= ( const B2DGPF & )

delete

void Basic2DGenericPFlowClusterizer::prunePFClusters ( reco::PFClusterCollection & clusters ) const

private

Definition at line 241 of file Basic2DGenericPFlowClusterizer.cc.

References PFClusterBuilderBase::_minFractionToKeep, and reco::PFRecHitFraction::fraction().

Referenced by buildClusters().

                                                          {
   for( auto& cluster : clusters ) {
     cluster.pruneUsing( [&](const reco::PFRecHitFraction& rhf)
             {return rhf.fraction() > _minFractionToKeep;} 
             );    
   }
 }

void Basic2DGenericPFlowClusterizer::seedPFClustersFromTopo	(	const reco::PFCluster &	topo,
		const std::vector< bool > &	seedable,
		reco::PFClusterCollection &	initialPFClusters
	)		const

private

Definition at line 113 of file Basic2DGenericPFlowClusterizer.cc.

References _convergencePosCalc, PFClusterBuilderBase::_positionCalc, reco::PFCluster::addRecHitFraction(), cond::rpcobimon::current, reco::PFCluster::recHitFractions(), and reco::CaloCluster::setSeed().

Referenced by buildClusters().

                                                                  {
   const auto& recHitFractions = topo.recHitFractions();
   for( const auto& rhf : recHitFractions ) {
     if( !seedable[rhf.recHitRef().key()] ) continue;
     initialPFClusters.push_back(reco::PFCluster());
     reco::PFCluster& current = initialPFClusters.back();
     current.addRecHitFraction(rhf);
     current.setSeed(rhf.recHitRef()->detId());   
     if( _convergencePosCalc ) {
       _convergencePosCalc->calculateAndSetPosition(current);
     } else {
       _positionCalc->calculateAndSetPosition(current);
     }
   }
 }

void Basic2DGenericPFlowClusterizer::update ( const edm::EventSetup & es )

inlinevirtual

Reimplemented from PFClusterBuilderBase.

Definition at line 18 of file Basic2DGenericPFlowClusterizer.h.

References _allCellsPosCalc, _convergencePosCalc, and PFClusterBuilderBase::_positionCalc.

                                        { 
     _positionCalc->update(es); 
     if( _allCellsPosCalc ) _allCellsPosCalc->update(es);
     if( _convergencePosCalc ) _convergencePosCalc->update(es);
   }