#include <Basic2DGenericPFlowPositionCalc.h>

Inheritance diagram for Basic2DGenericPFlowPositionCalc:

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

	Basic2DGenericPFlowPositionCalc (const Basic2DGenericPFlowPositionCalc &)=delete

void	calculateAndSetPosition (reco::PFCluster &)

void	calculateAndSetPositions (reco::PFClusterCollection &)

Basic2DGenericPFlowPositionCalc &	operator= (const Basic2DGenericPFlowPositionCalc &)=delete

Public Member Functions inherited from PFCPositionCalculatorBase
const std::string &	name () const

PosCalc &	operator= (const PosCalc &)=delete

	PFCPositionCalculatorBase (const edm::ParameterSet &conf)

	PFCPositionCalculatorBase (const PosCalc &)=delete

virtual void	update (const edm::EventSetup &)

	~PFCPositionCalculatorBase ()

Private Member Functions
void	calculateAndSetPositionActual (reco::PFCluster &) const

Private Attributes
const double	_logWeightDenom

const double	_minAllowedNorm

const int	_posCalcNCrystals

std::unique_ptr < CaloRecHitResolutionProvider >	_timeResolutionCalcBarrel

std::unique_ptr < CaloRecHitResolutionProvider >	_timeResolutionCalcEndcap

Additional Inherited Members
Protected Attributes inherited from PFCPositionCalculatorBase
const float	_minFractionInCalc

Detailed Description

Definition at line 10 of file Basic2DGenericPFlowPositionCalc.h.

Constructor & Destructor Documentation

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

inline

Definition at line 12 of file Basic2DGenericPFlowPositionCalc.h.

References _timeResolutionCalcBarrel, _timeResolutionCalcEndcap, edm::ParameterSet::exists(), edm::ParameterSet::getParameterSet(), and NULL.

                                                                :
     PFCPositionCalculatorBase(conf),    
     _posCalcNCrystals(conf.getParameter<int>("posCalcNCrystals")),
     _logWeightDenom(conf.getParameter<double>("logWeightDenominator")),
     _minAllowedNorm(conf.getParameter<double>("minAllowedNormalization"))
 
   {  
     _timeResolutionCalcBarrel.reset(NULL);
     if( conf.exists("timeResolutionCalcBarrel") ) {
       const edm::ParameterSet& timeResConf = 
         conf.getParameterSet("timeResolutionCalcBarrel");
         _timeResolutionCalcBarrel.reset(new CaloRecHitResolutionProvider(timeResConf));
     }
     _timeResolutionCalcEndcap.reset(NULL);
     if( conf.exists("timeResolutionCalcEndcap") ) {
       const edm::ParameterSet& timeResConf = 
         conf.getParameterSet("timeResolutionCalcEndcap");
         _timeResolutionCalcEndcap.reset(new CaloRecHitResolutionProvider(timeResConf));
     }
   }

Basic2DGenericPFlowPositionCalc::Basic2DGenericPFlowPositionCalc ( const Basic2DGenericPFlowPositionCalc & )

delete

Member Function Documentation

void Basic2DGenericPFlowPositionCalc::calculateAndSetPosition ( reco::PFCluster & cluster )

virtual

Implements PFCPositionCalculatorBase.

Definition at line 12 of file Basic2DGenericPFlowPositionCalc.cc.

References calculateAndSetPositionActual().

                                                 {
   calculateAndSetPositionActual(cluster);
 }

void Basic2DGenericPFlowPositionCalc::calculateAndSetPositionActual ( reco::PFCluster & cluster ) const

private

Definition at line 24 of file Basic2DGenericPFlowPositionCalc.cc.

References _logWeightDenom, _minAllowedNorm, PFCPositionCalculatorBase::_minFractionInCalc, _posCalcNCrystals, _timeResolutionCalcBarrel, _timeResolutionCalcEndcap, assert(), edm::RefVector< C, T, F >::begin(), reco::PFCluster::calculatePositionREP(), HLT_FULL_cff::depth, PFLayer::ECAL_BARREL, edm::RefVector< C, T, F >::end(), Exception, spr::find(), PFLayer::HCAL_BARREL1, PFLayer::HCAL_BARREL2, edm::isNotFinite(), bookConverter::max, PFLayer::NONE, reco::PFCluster::recHitFractions(), reco::CaloCluster::seed(), reco::PFCluster::setDepth(), reco::CaloCluster::setEnergy(), reco::PFCluster::setLayer(), reco::CaloCluster::setPosition(), reco::PFCluster::setTime(), x, y, and z.

Referenced by calculateAndSetPosition(), and calculateAndSetPositions().

                                                             {  
   if( !cluster.seed() ) {
     throw cms::Exception("ClusterWithNoSeed")
       << " Found a cluster with no seed: " << cluster;
   }                 
   double cl_energy = 0;  
   double cl_time = 0;  
   double cl_timeweight=0.0;
   double max_e = 0.0;  
   PFLayer::Layer max_e_layer = PFLayer::NONE;
   reco::PFRecHitRef refseed;  
   // find the seed and max layer and also calculate time
   //Michalis : Even if we dont use timing in clustering here we should fill
   //the time information for the cluster. This should use the timing resolution(1/E)
   //so the weight should be fraction*E^2
   //calculate a simplistic depth now. The log weighted will be done
   //in different stage  
   for( const reco::PFRecHitFraction& rhf : cluster.recHitFractions() ) {
     const reco::PFRecHitRef& refhit = rhf.recHitRef();
     if( refhit->detId() == cluster.seed() ) refseed = refhit;
     const double rh_fraction = rhf.fraction();
     const double rh_rawenergy = refhit->energy();
     const double rh_energy = rh_rawenergy * rh_fraction;   
     if( edm::isNotFinite(rh_energy) ) {
       throw cms::Exception("PFClusterAlgo")
     <<"rechit " << refhit->detId() << " has a NaN energy... " 
     << "The input of the particle flow clustering seems to be corrupted.";
     }
     cl_energy += rh_energy;
     // If time resolution is given, calculated weighted average
     if (_timeResolutionCalcBarrel && _timeResolutionCalcEndcap) {
       double res2 = 10000.;
       int cell_layer = (int)refhit->layer();
       if (cell_layer == PFLayer::HCAL_BARREL1 ||
           cell_layer == PFLayer::HCAL_BARREL2 ||
           cell_layer == PFLayer::ECAL_BARREL)
         res2 = _timeResolutionCalcBarrel->timeResolution2(rh_rawenergy);
       else
         res2 = _timeResolutionCalcEndcap->timeResolution2(rh_rawenergy);
       cl_time += rh_fraction*refhit->time()/res2;
       cl_timeweight += rh_fraction/res2;
     }
     else { // assume resolution = 1/E**2
       const double rh_rawenergy2 = rh_rawenergy*rh_rawenergy;
       cl_timeweight+=rh_rawenergy2*rh_fraction;
       cl_time += rh_rawenergy2*rh_fraction*refhit->time();
     }
 
     if( rh_energy > max_e ) {
       max_e = rh_energy;
       max_e_layer = rhf.recHitRef()->layer();
     }    
   }
   cluster.setEnergy(cl_energy);
   cluster.setTime(cl_time/cl_timeweight);
   cluster.setLayer(max_e_layer);
   // calculate the position
 
   double depth = 0.0;  
   double position_norm = 0.0;
   double x(0.0),y(0.0),z(0.0);
   const reco::PFRecHitRefVector* seedNeighbours = nullptr;
   switch( _posCalcNCrystals ) {
   case 5:
     seedNeighbours = &refseed->neighbours4();
     break;
   case 9:
     seedNeighbours = &refseed->neighbours8();
     break;
   case -1:
     break;
   default:
     assert(0); //bug
   }
 
   for( const reco::PFRecHitFraction& rhf : cluster.recHitFractions() ) {
     const reco::PFRecHitRef& refhit = rhf.recHitRef();
     
     if( refhit != refseed && _posCalcNCrystals != -1 ) {
       auto pos = std::find(seedNeighbours->begin(),seedNeighbours->end(),
                refhit);
       if( pos == seedNeighbours->end() ) continue;
     }
     
     const double rh_energy = refhit->energy() * ((float)rhf.fraction());
     const double norm = ( rhf.fraction() < _minFractionInCalc ? 
               0.0 : 
               std::max(0.0,vdt::fast_log(rh_energy/_logWeightDenom)) );
     const math::XYZPoint& rhpos_xyz = refhit->position();
     x += rhpos_xyz.X() * norm;
     y += rhpos_xyz.Y() * norm;
     z += rhpos_xyz.Z() * norm;
     depth += refhit->depth()*norm;
     
     position_norm += norm;
   }
   if( position_norm < _minAllowedNorm ) {
     edm::LogError("WeirdClusterNormalization") 
       << "PFCluster too far from seeding cell: set position to (0,0,0).";
     cluster.setPosition(math::XYZPoint(0,0,0));
     cluster.calculatePositionREP();
   } else {
     const double norm_inverse = 1.0/position_norm;
     x *= norm_inverse;
     y *= norm_inverse;
     z *= norm_inverse;
     depth *= norm_inverse;
     cluster.setPosition(math::XYZPoint(x,y,z));
     cluster.setDepth(depth);
     cluster.calculatePositionREP();
   }
 }

void Basic2DGenericPFlowPositionCalc::calculateAndSetPositions ( reco::PFClusterCollection & clusters )

virtual

Implements PFCPositionCalculatorBase.

Definition at line 17 of file Basic2DGenericPFlowPositionCalc.cc.

References calculateAndSetPositionActual().

                                                             {
   for( reco::PFCluster& cluster : clusters ) {
     calculateAndSetPositionActual(cluster);
   }
 }