#include <EcalClusterTools.h>

Classes
struct	EcalClusterEnergyDeposition

Static Public Member Functions
static Cluster2ndMoments	cluster2ndMoments (const reco::BasicCluster &basicCluster, const EcalRecHitCollection &recHits, double phiCorrectionFactor=0.8, double w0=4.7, bool useLogWeights=true)

static Cluster2ndMoments	cluster2ndMoments (const reco::SuperCluster &superCluster, const EcalRecHitCollection &recHits, double phiCorrectionFactor=0.8, double w0=4.7, bool useLogWeights=true)

static Cluster2ndMoments	cluster2ndMoments (const std::vector< std::pair< const EcalRecHit *, float > > &RH_ptrs_fracs, double phiCorrectionFactor=0.8, double w0=4.7, bool useLogWeights=true)

static std::vector< float >	covariances (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology, const CaloGeometry *geometry, float w0=4.7)

static float	e1x3 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e1x5 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e2nd (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)

static float	e2x2 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e2x5Bottom (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e2x5Left (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e2x5Max (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e2x5Right (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e2x5Top (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e3x1 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e3x2 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e3x3 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e4x4 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e5x1 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	e5x5 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	eBottom (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	eLeft (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	eMax (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)

static std::vector< float >	energyBasketFractionEta (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)

static std::vector< float >	energyBasketFractionPhi (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)

static float	eRight (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	eTop (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	getFraction (const std::vector< std::pair< DetId, float > > &v_id, DetId id)

static std::pair< DetId, float >	getMaximum (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)

static std::pair< DetId, float >	getMaximum (const std::vector< std::pair< DetId, float > > &v_id, const EcalRecHitCollection *recHits)

static std::vector< float >	lat (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloGeometry geometry, bool logW=true, float w0=4.7)

static std::vector< float >	localCovariances (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology, float w0=4.7)

static std::vector< DetId >	matrixDetId (const CaloTopology *topology, DetId id, CaloRectangle rectangle)

static std::vector< DetId >	matrixDetId (const CaloTopology *topology, DetId id, int size)

static float	matrixEnergy (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology, DetId id, CaloRectangle rectangle)

static int	matrixSize (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology, DetId id, CaloRectangle rectangle)

static int	n5x5 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static int	nrSaturatedCrysIn5x5 (const DetId &id, const EcalRecHitCollection recHits, const CaloTopology topology)

static float	recHitEnergy (DetId id, const EcalRecHitCollection *recHits)

static std::vector< float >	roundnessBarrelSuperClusters (const reco::SuperCluster &superCluster, const EcalRecHitCollection &recHits, int weightedPositionMethod=0, float energyThreshold=0.0)

static std::vector< float >	roundnessBarrelSuperClustersUserExtended (const reco::SuperCluster &superCluster, const EcalRecHitCollection &recHits, int ieta_delta=0, int iphi_delta=0, float energyRHThresh=0.00000, int weightedPositionMethod=0)

static std::vector< float >	roundnessSelectedBarrelRecHits (const std::vector< std::pair< const EcalRecHit *, float > > &rhVector, int weightedPositionMethod=0)

static std::vector< float >	scLocalCovariances (const reco::SuperCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology, float w0=4.7)

static double	zernike20 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloGeometry geometry, double R0=6.6, bool logW=true, float w0=4.7)

static double	zernike42 (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloGeometry geometry, double R0=6.6, bool logW=true, float w0=4.7)

Static Private Member Functions
static double	absZernikeMoment (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloGeometry geometry, int n, int m, double R0, bool logW, float w0)

static double	calc_AbsZernikeMoment (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloGeometry geometry, int n, int m, double R0, bool logW, float w0)

static float	computeWeight (float eRH, float energyTotal, int weightedPositionMethod)

static int	deltaIEta (int seed_ieta, int rh_ieta)

static int	deltaIPhi (int seed_iphi, int rh_iphi)

static double	f00 (double r)

static double	f11 (double r)

static double	f20 (double r)

static double	f22 (double r)

static double	f31 (double r)

static double	f33 (double r)

static double	f40 (double r)

static double	f42 (double r)

static double	f44 (double r)

static double	f51 (double r)

static double	f53 (double r)

static double	f55 (double r)

static double	factorial (int n)

static double	fast_AbsZernikeMoment (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloGeometry geometry, int n, int m, double R0, bool logW, float w0)

static float	getDPhiEndcap (const DetId &crysId, float meanX, float meanY)

static std::vector< EcalClusterEnergyDeposition >	getEnergyDepTopology (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloGeometry geometry, bool logW, float w0)

static float	getIEta (const DetId &id)

static float	getIPhi (const DetId &id)

static float	getNormedIX (const DetId &id)

static float	getNormedIY (const DetId &id)

static float	getNrCrysDiffInEta (const DetId &crysId, const DetId &orginId)

static float	getNrCrysDiffInPhi (const DetId &crysId, const DetId &orginId)

static std::vector< int >	getSeedPosition (const std::vector< std::pair< const EcalRecHit *, float > > &RH_ptrs)

static float	getSumEnergy (const std::vector< std::pair< const EcalRecHit *, float > > &RH_ptrs_fracs)

static std::pair< float, float >	mean5x5PositionInLocalCrysCoord (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static std::pair< float, float >	mean5x5PositionInXY (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology)

static math::XYZVector	meanClusterPosition (const reco::BasicCluster &cluster, const EcalRecHitCollection recHits, const CaloTopology topology, const CaloGeometry *geometry)

Detailed Description

template<bool noZS>
class EcalClusterToolsT< noZS >

Definition at line 77 of file EcalClusterTools.h.

Member Function Documentation

template<bool noZS>

double EcalClusterToolsT< noZS >::absZernikeMoment	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloGeometry *	geometry,
		int	n,
		int	m,
		double	R0,
		bool	logW,
		float	w0
	)

staticprivate

Definition at line 947 of file EcalClusterTools.h.

 {
     // 1. Check if n,m are correctly
     if ((m>n) || ((n-m)%2 != 0) || (n<0) || (m<0)) return -1;
 
     // 2. Check if n,R0 are within validity Range :
     // n>20 or R0<2.19cm  just makes no sense !
     if ((n>20) || (R0<=2.19)) return -1;
     if (n<=5) return fast_AbsZernikeMoment(cluster, recHits, geometry, n, m, R0, logW, w0 );
     else return calc_AbsZernikeMoment(cluster, recHits, geometry, n, m, R0, logW, w0 );
 }

template<bool noZS>

double EcalClusterToolsT< noZS >::calc_AbsZernikeMoment	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloGeometry *	geometry,
		int	n,
		int	m,
		double	R0,
		bool	logW,
		float	w0
	)

staticprivate

Definition at line 996 of file EcalClusterTools.h.

References funct::cos(), MillePedeFileConverter_cfg::e, factorial(), mps_fire::i, funct::m, funct::pow(), alignCSCRings::r, pfBoostedDoubleSVAK8TagInfos_cfi::R0, alignCSCRings::s, funct::sin(), and mathSSE::sqrt().

 {
     double r, ph, e, Re=0, Im=0, f_nm;
     double TotalEnergy = cluster.energy();
     std::vector<EcalClusterEnergyDeposition> energyDistribution = getEnergyDepTopology( cluster, recHits, geometry, logW, w0 );
     int clusterSize=energyDistribution.size();
     if(clusterSize<3) return 0.0;
 
     for (int i = 0; i < clusterSize; ++i)
     { 
         r = energyDistribution[i].r / R0;
         if (r < 1) {
             ph = energyDistribution[i].phi;
             e = energyDistribution[i].deposited_energy;
             f_nm = 0;
             for (int s=0; s<=(n-m)/2; s++) {
                 if (s%2==0) { 
                     f_nm = f_nm + factorial(n-s)*pow(r,(double) (n-2*s))/(factorial(s)*factorial((n+m)/2-s)*factorial((n-m)/2-s));
                 } else {
                     f_nm = f_nm - factorial(n-s)*pow(r,(double) (n-2*s))/(factorial(s)*factorial((n+m)/2-s)*factorial((n-m)/2-s));
                 }
             }
             Re = Re + e/TotalEnergy * f_nm * cos( (double) m*ph);
             Im = Im - e/TotalEnergy * f_nm * sin( (double) m*ph);
         }
     }
     return sqrt(Re*Re+Im*Im);
 }

template<bool noZS>

Cluster2ndMoments EcalClusterToolsT< noZS >::cluster2ndMoments	(	const reco::BasicCluster &	basicCluster,
		const EcalRecHitCollection &	recHits,
		double	phiCorrectionFactor = `0.8`,
		double	w0 = `4.7`,
		bool	useLogWeights = `true`
	)

static

Definition at line 1231 of file EcalClusterTools.h.

References Cluster2ndMoments::Cluster2ndMoments(), edm::SortedCollection< T, SORT >::empty(), edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), plotBeamSpotDB::first, mps_fire::i, and edm::second().

Referenced by EcalClusterToolsT< noZS >::cluster2ndMoments(), GEDPhotonProducer::fillPhotonCollection(), and EG9X105XObjectUpdateModifier::modifyObject().

                                                                                                                                                                                                   {
 
   if(recHits.empty()) return Cluster2ndMoments();
 
   std::vector<std::pair<const EcalRecHit*, float> > RH_ptrs_fracs;
   
   const std::vector< std::pair<DetId, float> >& myHitsPair = basicCluster.hitsAndFractions();
   
   for(unsigned int i=0; i<myHitsPair.size(); i++){
     //get pointer to recHit object
     EcalRecHitCollection::const_iterator myRH = recHits.find(myHitsPair[i].first);
     if(myRH != recHits.end()){
       RH_ptrs_fracs.push_back(  std::make_pair(&(*myRH) , myHitsPair[i].second)  );
     }
   }
   
   return EcalClusterToolsT<noZS>::cluster2ndMoments(RH_ptrs_fracs, phiCorrectionFactor, w0, useLogWeights);
 }

template<bool noZS>

Cluster2ndMoments EcalClusterToolsT< noZS >::cluster2ndMoments	(	const reco::SuperCluster &	superCluster,
		const EcalRecHitCollection &	recHits,
		double	phiCorrectionFactor = `0.8`,
		double	w0 = `4.7`,
		bool	useLogWeights = `true`
	)

static

Definition at line 1251 of file EcalClusterTools.h.

References EcalClusterToolsT< noZS >::cluster2ndMoments(), and reco::SuperCluster::seed().

                                                                                                                                                                                                   {
 
   return EcalClusterToolsT<noZS>::cluster2ndMoments( *(superCluster.seed()), recHits, phiCorrectionFactor, w0, useLogWeights);
 
 }

template<bool noZS>

Cluster2ndMoments EcalClusterToolsT< noZS >::cluster2ndMoments	(	const std::vector< std::pair< const EcalRecHit *, float > > &	RH_ptrs_fracs,
		double	phiCorrectionFactor = `0.8`,
		double	w0 = `4.7`,
		bool	useLogWeights = `true`
	)

static

Definition at line 1258 of file EcalClusterTools.h.

References funct::abs(), Cluster2ndMoments::alpha, Cluster2ndMoments::Cluster2ndMoments(), pfDeepCMVADiscriminatorsJetTags_cfi::denominator, EcalRecHit::detid(), EcalBarrel, EcalRecHit::energy(), EcalClusterToolsT< noZS >::getSumEnergy(), mps_fire::i, GeomDetEnumerators::isBarrel(), cmsBatch::log, SiStripPI::max, phi, Cluster2ndMoments::sMaj, Cluster2ndMoments::sMin, mathSSE::sqrt(), and DetId::subdetId().

                                                                                                                                                                                            {
 
   if(RH_ptrs_fracs.empty()) return Cluster2ndMoments();
 
   double mid_eta(0),mid_phi(0),mid_x(0),mid_y(0);
   
   double Etot = EcalClusterToolsT<noZS>::getSumEnergy(  RH_ptrs_fracs  );
  
   double max_phi=-10.;
   double min_phi=100.;
   
   
   std::vector<double> etaDetId;
   std::vector<double> phiDetId;
   std::vector<double> xDetId;
   std::vector<double> yDetId;
   std::vector<double> wiDetId;
  
   unsigned int nCry=0;
   double denominator=0.;
   bool isBarrel(true);
 
   // loop over rechits and compute weights:
   for(std::vector<std::pair<const EcalRecHit*, float> >::const_iterator rhf_ptr = RH_ptrs_fracs.begin(); rhf_ptr != RH_ptrs_fracs.end(); rhf_ptr++){
     const EcalRecHit* rh_ptr = rhf_ptr->first;
 
 
     //get iEta, iPhi
     double temp_eta(0),temp_phi(0),temp_x(0),temp_y(0);
     isBarrel = rh_ptr->detid().subdetId()==EcalBarrel;
     
     if(isBarrel) {
       temp_eta = (getIEta(rh_ptr->detid()) > 0. ? getIEta(rh_ptr->detid()) + 84.5 : getIEta(rh_ptr->detid()) + 85.5);
       temp_phi= getIPhi(rh_ptr->detid()) - 0.5;
     }
     else {
       temp_eta = getIEta(rh_ptr->detid());  
       temp_x =  getNormedIX(rh_ptr->detid());
       temp_y =  getNormedIY(rh_ptr->detid());
     }     
 
     double temp_ene=rh_ptr->energy() * (noZS ? 1.0 : rhf_ptr->second);
     
     double temp_wi=((useLogWeights) ?
                     std::max(0.0, w0 + std::log( std::abs(temp_ene)/Etot ))
                     :  temp_ene);
 
 
     if(temp_phi>max_phi) max_phi=temp_phi;
     if(temp_phi<min_phi) min_phi=temp_phi;
     etaDetId.push_back(temp_eta);
     phiDetId.push_back(temp_phi);
     xDetId.push_back(temp_x);
     yDetId.push_back(temp_y);
     wiDetId.push_back(temp_wi);
     denominator+=temp_wi;
     nCry++;
   }
 
   if(isBarrel){
     // correct phi wrap-around:
     if(max_phi==359.5 && min_phi==0.5){ 
       for(unsigned int i=0; i<nCry; i++){
         if(phiDetId[i] - 179. > 0.) phiDetId[i]-=360.; 
         mid_phi+=phiDetId[i]*wiDetId[i];
         mid_eta+=etaDetId[i]*wiDetId[i];
       }
     } else{
       for(unsigned int i=0; i<nCry; i++){
         mid_phi+=phiDetId[i]*wiDetId[i];
         mid_eta+=etaDetId[i]*wiDetId[i];
       }
     }
   }else{
     for(unsigned int i=0; i<nCry; i++){
       mid_eta+=etaDetId[i]*wiDetId[i];      
       mid_x+=xDetId[i]*wiDetId[i];
       mid_y+=yDetId[i]*wiDetId[i];
     }
   }
   
   mid_eta/=denominator;
   mid_phi/=denominator;
   mid_x/=denominator;
   mid_y/=denominator;
 
 
   // See = sigma eta eta
   // Spp = (B field corrected) sigma phi phi
   // See = (B field corrected) sigma eta phi
   double See=0.;
   double Spp=0.;
   double Sep=0.;
   double deta(0),dphi(0);
   // compute (phi-corrected) covariance matrix:
   for(unsigned int i=0; i<nCry; i++) {
     if(isBarrel) {
       deta = etaDetId[i]-mid_eta;
       dphi = phiDetId[i]-mid_phi;
     } else {
       deta = etaDetId[i]-mid_eta;
       float hitLocalR2 = (xDetId[i]-mid_x)*(xDetId[i]-mid_x)+(yDetId[i]-mid_y)*(yDetId[i]-mid_y);
       float hitR2 = xDetId[i]*xDetId[i]+yDetId[i]*yDetId[i];
       float meanR2 = mid_x*mid_x+mid_y*mid_y;
       float hitR = sqrt(hitR2);
       float meanR = sqrt(meanR2);
       float phi = acos((hitR2+meanR2-hitLocalR2)/(2*hitR*meanR));
       dphi = hitR*phi;
 
     }
     See += (wiDetId[i]* deta * deta) / denominator;
     Spp += phiCorrectionFactor*(wiDetId[i]* dphi * dphi) / denominator;
     Sep += sqrt(phiCorrectionFactor)*(wiDetId[i]*deta*dphi) / denominator;
   }
 
   Cluster2ndMoments returnMoments;
 
   // compute matrix eigenvalues:
   returnMoments.sMaj = ((See + Spp) + sqrt((See - Spp)*(See - Spp) + 4.*Sep*Sep)) / 2.;
   returnMoments.sMin = ((See + Spp) - sqrt((See - Spp)*(See - Spp) + 4.*Sep*Sep)) / 2.;
 
   returnMoments.alpha = atan( (See - Spp + sqrt( (Spp - See)*(Spp - See) + 4.*Sep*Sep )) / (2.*Sep));
 
   return returnMoments;
 
 }

template<bool noZS>

static float EcalClusterToolsT< noZS >::computeWeight	(	float	eRH,
		float	energyTotal,
		int	weightedPositionMethod
	)

staticprivate

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::covariances	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology,
		const CaloGeometry *	geometry,
		float	w0 = `4.7`
	)

static

Definition at line 789 of file EcalClusterTools.h.

References pfDeepCMVADiscriminatorsJetTags_cfi::denominator, particleFlow_cfi::dEta, particleFlow_cfi::dPhi, PV3DBase< T, PVType, FrameType >::eta(), f, DivergingColor::frac, CaloSubdetectorGeometry::getGeometry(), CaloGeometry::getSubdetectorGeometry(), cmsBatch::log, SiStripPI::max, PV3DBase< T, PVType, FrameType >::phi(), Geom::pi(), position, Geom::twoPi(), findQualityFiles::v, and w.

Referenced by GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), PhotonProducer::fillPhotonCollection(), and GEDPhotonProducer::fillPhotonCollection().

 {
     float e_5x5 = e5x5( cluster, recHits, topology );
     float covEtaEta, covEtaPhi, covPhiPhi;
     if (e_5x5 >= 0.) {
         //double w0_ = parameterMap_.find("W0")->second;
         const std::vector< std::pair<DetId, float>>& v_id =cluster.hitsAndFractions();
         math::XYZVector meanPosition = meanClusterPosition( cluster, recHits, topology, geometry );
 
         // now we can calculate the covariances
         double numeratorEtaEta = 0;
         double numeratorEtaPhi = 0;
         double numeratorPhiPhi = 0;
         double denominator     = 0;
 
         DetId id = getMaximum( v_id, recHits ).first;
         CaloRectangle rectangle{-2, 2, -2, 2};
         for (auto const& detId : rectangle(id, *topology)) {
             float frac=getFraction(v_id,detId);
             float energy = recHitEnergy( detId, recHits )*frac;
 
             if ( energy <= 0 ) continue;
 
             const CaloSubdetectorGeometry* geo = geometry->getSubdetectorGeometry(detId);
             GlobalPoint position = geo->getGeometry(detId)->getPosition();
 
             double dPhi = position.phi() - meanPosition.phi();
             if (dPhi > + Geom::pi()) { dPhi = Geom::twoPi() - dPhi; }
             if (dPhi < - Geom::pi()) { dPhi = Geom::twoPi() + dPhi; }
 
             double dEta = position.eta() - meanPosition.eta();
             double w = 0.;
             w = std::max(0.0f, w0 + std::log( energy / e_5x5 ));
 
             denominator += w;
             numeratorEtaEta += w * dEta * dEta;
             numeratorEtaPhi += w * dEta * dPhi;
             numeratorPhiPhi += w * dPhi * dPhi;
         }
 
         if (denominator != 0.0) {
             covEtaEta =  numeratorEtaEta / denominator;
             covEtaPhi =  numeratorEtaPhi / denominator;
             covPhiPhi =  numeratorPhiPhi / denominator;
         } else {
             covEtaEta = 999.9;
             covEtaPhi = 999.9;
             covPhiPhi = 999.9;
         }
 
     } else {
         // Warn the user if there was no energy in the cells and return zeroes.
         //       std::cout << "\ClusterShapeAlgo::Calculate_Covariances:  no energy in supplied cells.\n";
         covEtaEta = 0;
         covEtaPhi = 0;
         covPhiPhi = 0;
     }
     std::vector<float> v;
     v.push_back( covEtaEta );
     v.push_back( covEtaPhi );
     v.push_back( covPhiPhi );
     return v;
 }

template<bool noZS>

int EcalClusterToolsT< noZS >::deltaIEta	(	int	seed_ieta,
		int	rh_ieta
	)

staticprivate

Definition at line 1622 of file EcalClusterTools.h.

                                                                 {
     // get rid of the fact that there is no ieta=0
     if(seed_ieta < 0) seed_ieta++;
     if(rh_ieta   < 0) rh_ieta++;
     int rel_ieta = rh_ieta - seed_ieta;
     return rel_ieta;
 }

template<bool noZS>

int EcalClusterToolsT< noZS >::deltaIPhi	(	int	seed_iphi,
		int	rh_iphi
	)

staticprivate

Definition at line 1610 of file EcalClusterTools.h.

                                                                 {
     int rel_iphi = rh_iphi - seed_iphi;
     // take care of cyclic variable iphi [1,360]
     if(rel_iphi >  180) rel_iphi = rel_iphi - 360;
     if(rel_iphi < -180) rel_iphi = rel_iphi + 360;
     return rel_iphi;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e1x3	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 503 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {0, 0, -1, 1} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e1x5	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 489 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), PhotonProducer::fillPhotonCollection(), and GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {0, 0, -2, 2} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e2nd	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits
	)

static

Definition at line 429 of file EcalClusterTools.h.

References plotBeamSpotDB::first, mps_fire::i, and edm::second().

Referenced by GEDPhotonProducer::fillPhotonCollection().

 {
     std::vector<float> energies;
     const std::vector< std::pair<DetId, float> >& v_id = cluster.hitsAndFractions();
     energies.reserve( v_id.size() );
     if ( v_id.size() < 2 ) return 0;
     for ( size_t i = 0; i < v_id.size(); ++i ) {
       energies.push_back( recHitEnergy( v_id[i].first, recHits ) * (noZS ? 1.0 : v_id[i].second) );
     }
     std::partial_sort( energies.begin(), energies.begin()+2, energies.end(), std::greater<float>() );
     return energies[1];
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x2	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 368 of file EcalClusterTools.h.

References plotBeamSpotDB::first, and SiStripPI::max.

Referenced by GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     std::list<float> energies;
     float max_E =  matrixEnergy( cluster, recHits, topology, id, {-1, 0, -1, 0} );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id, {-1, 0,  0, 1} ) );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id, { 0, 1,  0, 1} ) );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id, { 0, 1, -1, 0} ) );
     return max_E;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Bottom	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 464 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection(), and EG8XObjectUpdateModifier::modifyObject().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {-2, 2, -2, -1} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Left	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 450 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection(), and EG8XObjectUpdateModifier::modifyObject().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {-2, -1, -2, 2} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Max	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 473 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), PhotonProducer::fillPhotonCollection(), and GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id =      getMaximum( cluster.hitsAndFractions(), recHits ).first;
 
     // 1x5 strip left of seed
     float left   = matrixEnergy( cluster, recHits, topology, id, {-1, -1, -2, 2} );
     // 1x5 strip right of seed
     float right  = matrixEnergy( cluster, recHits, topology, id,  {1,  1, -2, 2} );
     // 1x5 strip containing seed
     float centre = matrixEnergy( cluster, recHits, topology, id,  {0,  0, -2, 2} );
 
     // Return the maximum of (left+center) or (right+center) strip
     return left > right ? left+centre : right+centre;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Right	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 443 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection(), and EG8XObjectUpdateModifier::modifyObject().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {1, 2, -2, 2} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Top	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 457 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection(), and EG8XObjectUpdateModifier::modifyObject().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {-2, 2, 1, 2} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e3x1	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 510 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {-1, 1, 0, 0} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e3x2	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 380 of file EcalClusterTools.h.

References plotBeamSpotDB::first, and SiStripPI::max.

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     float max_E = matrixEnergy( cluster, recHits, topology, id, {-1, 1, -1, 0} );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id,  {0, 1, -1, 1} ) );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id, {-1, 1,  0, 1} ) );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id, {-1, 0, -1, 1} ) );
     return max_E;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e3x3	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 391 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), PhotonProducer::fillPhotonCollection(), and GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {-1, 1, -1, 1} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e4x4	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 398 of file EcalClusterTools.h.

References plotBeamSpotDB::first, and SiStripPI::max.

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;    
     float max_E = matrixEnergy( cluster, recHits, topology, id, {-1, 2, -2, 1} );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id, {-2, 1, -2, 1} ) );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id, {-2, 1, -1, 2} ) );
     max_E = std::max( max_E, matrixEnergy( cluster, recHits, topology, id, {-1, 2, -1, 2} ) );
     return max_E;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e5x1	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 496 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {-2, 2, 0, 0} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::e5x5	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 409 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), PhotonProducer::fillPhotonCollection(), and GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {-2, 2, -2, 2} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::eBottom	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 538 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {0, 0, -1, -1} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::eLeft	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 517 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {-1, -1, 0, 0} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::eMax	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits
	)

static

Definition at line 423 of file EcalClusterTools.h.

References edm::second().

Referenced by PhotonProducer::fillPhotonCollection(), and GEDPhotonProducer::fillPhotonCollection().

 {
     return getMaximum( cluster.hitsAndFractions(), recHits ).second;
 }

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::energyBasketFractionEta	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits
	)

static

Definition at line 545 of file EcalClusterTools.h.

References EcalBarrel, plotBeamSpotDB::first, mps_fire::i, EBDetId::im(), EBDetId::kModulesPerSM, and EBDetId::positiveZ().

 {
     std::vector<float> basketFraction( 2 * EBDetId::kModulesPerSM );
     float clusterEnergy = cluster.energy();
     const std::vector< std::pair<DetId, float> >& v_id = cluster.hitsAndFractions();
     if ( v_id[0].first.subdetId() != EcalBarrel ) {
         edm::LogWarning("EcalClusterToolsT<noZS>::energyBasketFractionEta") << "Trying to get basket fraction for endcap basic-clusters. Basket fractions can be obtained ONLY for barrel basic-clusters. Returning empty vector.";
         return basketFraction;
     }
     for ( size_t i = 0; i < v_id.size(); ++i ) {
         basketFraction[ EBDetId(v_id[i].first).im()-1 + EBDetId(v_id[i].first).positiveZ()*EBDetId::kModulesPerSM ] += recHitEnergy( v_id[i].first, recHits ) * v_id[i].second / clusterEnergy;
     }
     std::sort( basketFraction.rbegin(), basketFraction.rend() );
     return basketFraction;
 }

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::energyBasketFractionPhi	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits
	)

static

Definition at line 562 of file EcalClusterTools.h.

References EcalBarrel, plotBeamSpotDB::first, mps_fire::i, EBDetId::iphi(), EBDetId::kCrystalsInPhi, EBDetId::kTowersInPhi, EBDetId::MAX_IPHI, and EBDetId::positiveZ().

 {
     std::vector<float> basketFraction( 2 * (EBDetId::MAX_IPHI / EBDetId::kCrystalsInPhi) );
     float clusterEnergy = cluster.energy();
     const std::vector< std::pair<DetId, float> >& v_id = cluster.hitsAndFractions();
     if ( v_id[0].first.subdetId() != EcalBarrel ) {
         edm::LogWarning("EcalClusterToolsT<noZS>::energyBasketFractionPhi") << "Trying to get basket fraction for endcap basic-clusters. Basket fractions can be obtained ONLY for barrel basic-clusters. Returning empty vector.";
         return basketFraction;
     }
     for ( size_t i = 0; i < v_id.size(); ++i ) {
       basketFraction[ (EBDetId(v_id[i].first).iphi()-1)/EBDetId::kCrystalsInPhi + EBDetId(v_id[i].first).positiveZ()*EBDetId::kTowersInPhi] += recHitEnergy( v_id[i].first, recHits ) * (noZS ? 1.0 : v_id[i].second) / clusterEnergy;
     }
     std::sort( basketFraction.rbegin(), basketFraction.rend() );
     return basketFraction;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::eRight	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 524 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {1, 1, 0, 0} );
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::eTop	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 531 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

Referenced by GEDPhotonProducer::fillPhotonCollection().

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixEnergy( cluster, recHits, topology, id, {0, 0, 1, 1} );
 }

template<bool noZS>

static double EcalClusterToolsT< noZS >::f00 ( double r )

inlinestaticprivate

Definition at line 215 of file EcalClusterTools.h.

215 { return 1; }

template<bool noZS>

static double EcalClusterToolsT< noZS >::f11 ( double r )

inlinestaticprivate

Definition at line 216 of file EcalClusterTools.h.

References alignCSCRings::r.

216 { return r; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

template<bool noZS>

static double EcalClusterToolsT< noZS >::f20 ( double r )

inlinestaticprivate

Definition at line 217 of file EcalClusterTools.h.

217 { return 2.0*r*r-1.0; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

template<bool noZS>

static double EcalClusterToolsT< noZS >::f22 ( double r )

inlinestaticprivate

Definition at line 218 of file EcalClusterTools.h.

References alignCSCRings::r.

218 { return r*r; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

template<bool noZS>

static double EcalClusterToolsT< noZS >::f31 ( double r )

inlinestaticprivate

Definition at line 219 of file EcalClusterTools.h.

References alignCSCRings::r.

219 { return 3.0*r*r*r - 2.0*r; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

template<bool noZS>

static double EcalClusterToolsT< noZS >::f33 ( double r )

inlinestaticprivate

Definition at line 220 of file EcalClusterTools.h.

References alignCSCRings::r.

220 { return r*r*r; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

template<bool noZS>

static double EcalClusterToolsT< noZS >::f40 ( double r )

inlinestaticprivate

Definition at line 221 of file EcalClusterTools.h.

221 { return 6.0*r*r*r*r-6.0*r*r+1.0; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

template<bool noZS>

static double EcalClusterToolsT< noZS >::f42 ( double r )

inlinestaticprivate

Definition at line 222 of file EcalClusterTools.h.

References alignCSCRings::r.

222 { return 4.0*r*r*r*r-3.0*r*r; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

template<bool noZS>

static double EcalClusterToolsT< noZS >::f44 ( double r )

inlinestaticprivate

Definition at line 223 of file EcalClusterTools.h.

References alignCSCRings::r.

223 { return r*r*r*r; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

template<bool noZS>

static double EcalClusterToolsT< noZS >::f51 ( double r )

inlinestaticprivate

Definition at line 224 of file EcalClusterTools.h.

References funct::pow(), and alignCSCRings::r.

224 { return 10.0*pow(r,5)-12.0*pow(r,3)+3.0*r; }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

funct::pow

Power< A, B >::type pow(const A &a, const B &b)

Definition: Power.h:40

template<bool noZS>

static double EcalClusterToolsT< noZS >::f53 ( double r )

inlinestaticprivate

Definition at line 225 of file EcalClusterTools.h.

References funct::pow().

225 { return 5.0*pow(r,5) - 4.0*pow(r,3); }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

funct::pow

Power< A, B >::type pow(const A &a, const B &b)

Definition: Power.h:40

template<bool noZS>

static double EcalClusterToolsT< noZS >::f55 ( double r )

inlinestaticprivate

Definition at line 226 of file EcalClusterTools.h.

References funct::m, gen::n, funct::pow(), and pfBoostedDoubleSVAK8TagInfos_cfi::R0.

226 { return pow(r,5); }

alignCSCRings.r

r

Definition: alignCSCRings.py:93

funct::pow

Power< A, B >::type pow(const A &a, const B &b)

Definition: Power.h:40

template<bool noZS>

static double EcalClusterToolsT< noZS >::factorial ( int n )

inlinestaticprivate

Definition at line 232 of file EcalClusterTools.h.

References mps_fire::i, and gen::n.

                                                {
                         double res = 1.;
                         for (int i = 2; i <= n; ++i) res *= i;
                         return res;
                 }

template<bool noZS>

double EcalClusterToolsT< noZS >::fast_AbsZernikeMoment	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloGeometry *	geometry,
		int	n,
		int	m,
		double	R0,
		bool	logW,
		float	w0
	)

staticprivate

Definition at line 960 of file EcalClusterTools.h.

References funct::cos(), MillePedeFileConverter_cfg::e, mps_fire::i, phi, alignCSCRings::r, pfBoostedDoubleSVAK8TagInfos_cfi::R0, funct::sin(), and mathSSE::sqrt().

 {
     double r,ph,e,Re=0,Im=0;
     double TotalEnergy = cluster.energy();
     int index = (n/2)*(n/2)+(n/2)+m;
     std::vector<EcalClusterEnergyDeposition> energyDistribution = getEnergyDepTopology( cluster, recHits, geometry, logW, w0 );
     int clusterSize = energyDistribution.size();
     if(clusterSize < 3) return 0.0;
 
     for (int i=0; i<clusterSize; i++)
     { 
         r = energyDistribution[i].r / R0;
         if (r<1) {
             std::vector<double> pol;
             pol.push_back( f00(r) );
             pol.push_back( f11(r) );
             pol.push_back( f20(r) );
             pol.push_back( f22(r) );
             pol.push_back( f31(r) );
             pol.push_back( f33(r) );
             pol.push_back( f40(r) );
             pol.push_back( f42(r) );
             pol.push_back( f44(r) );
             pol.push_back( f51(r) );
             pol.push_back( f53(r) );
             pol.push_back( f55(r) );
             ph = (energyDistribution[i]).phi;
             e = energyDistribution[i].deposited_energy;
             Re = Re + e/TotalEnergy * pol[index] * cos( (double) m * ph);
             Im = Im - e/TotalEnergy * pol[index] * sin( (double) m * ph);
         }
     }
     return sqrt(Re*Re+Im*Im);
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getDPhiEndcap	(	const DetId &	crysId,
		float	meanX,
		float	meanY
	)

staticprivate

Definition at line 1129 of file EcalClusterTools.h.

References particleFlow_cfi::dPhi, phi, mathSSE::sqrt(), and tmp.

 {
     float iXNorm  = getNormedIX(crysId);
     float iYNorm  = getNormedIY(crysId);
 
     float hitLocalR2 = (iXNorm-meanX)*(iXNorm-meanX)+(iYNorm-meanY)*(iYNorm-meanY);
     float hitR2 = iXNorm*iXNorm+iYNorm*iYNorm;
     float meanR2 = meanX*meanX+meanY*meanY;
     float hitR = sqrt(hitR2);
     float meanR = sqrt(meanR2);
 
     float tmp = (hitR2+meanR2-hitLocalR2)/(2*hitR*meanR);
     if (tmp<-1) tmp =-1;
     if (tmp>1)  tmp=1;
     float phi = acos(tmp);
     float dPhi = hitR*phi;
 
     return dPhi;
 }

template<bool noZS>

std::vector< typename EcalClusterToolsT< noZS >::EcalClusterEnergyDeposition > EcalClusterToolsT< noZS >::getEnergyDepTopology	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloGeometry *	geometry,
		bool	logW,
		float	w0
	)

staticprivate

Definition at line 579 of file EcalClusterTools.h.

References funct::abs(), EcalClusterToolsT< noZS >::EcalClusterEnergyDeposition::deposited_energy, diffTreeTool::diff, edm::SortedCollection< T, SORT >::end(), EcalRecHit::energy(), edm::SortedCollection< T, SORT >::find(), CaloSubdetectorGeometry::getGeometry(), CaloGeometry::getSubdetectorGeometry(), cmsBatch::log, LogDebug, M_PI, SiStripPI::max, EcalClusterToolsT< noZS >::EcalClusterEnergyDeposition::phi, EcalClusterToolsT< noZS >::EcalClusterEnergyDeposition::r, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

 {
     std::vector<typename EcalClusterToolsT<noZS>::EcalClusterEnergyDeposition> energyDistribution;
     // init a map of the energy deposition centered on the
     // cluster centroid. This is for momenta calculation only.
     CLHEP::Hep3Vector clVect(cluster.position().x(), cluster.position().y(), cluster.position().z());
     CLHEP::Hep3Vector clDir(clVect);
     clDir*=1.0/clDir.mag();
     // in the transverse plane, axis perpendicular to clusterDir
     CLHEP::Hep3Vector theta_axis(clDir.y(),-clDir.x(),0.0);
     theta_axis *= 1.0/theta_axis.mag();
     CLHEP::Hep3Vector phi_axis = theta_axis.cross(clDir);
 
     const std::vector< std::pair<DetId, float> >& clusterDetIds = cluster.hitsAndFractions();
 
     EcalClusterEnergyDeposition clEdep;
     EcalRecHit testEcalRecHit;
     std::vector< std::pair<DetId, float> >::const_iterator posCurrent;
     // loop over crystals
     for(posCurrent=clusterDetIds.begin(); posCurrent!=clusterDetIds.end(); ++posCurrent) {
         EcalRecHitCollection::const_iterator itt = recHits->find( (*posCurrent).first );
         testEcalRecHit=*itt;
 
         if(( (*posCurrent).first != DetId(0)) && (recHits->find( (*posCurrent).first ) != recHits->end())) {
             clEdep.deposited_energy = testEcalRecHit.energy() * (noZS ? 1.0 : (*posCurrent).second);
             // if logarithmic weight is requested, apply cut on minimum energy of the recHit
             if(logW) {
                 //double w0 = parameterMap_.find("W0")->second;
 
             double weight = std::max(0.0, w0 + log(std::abs(clEdep.deposited_energy)/cluster.energy()) );
                 if(weight==0) {
                     LogDebug("ClusterShapeAlgo") << "Crystal has insufficient energy: E = " 
                         << clEdep.deposited_energy << " GeV; skipping... ";
                     continue;
                 }
                 else LogDebug("ClusterShapeAlgo") << "===> got crystal. Energy = " << clEdep.deposited_energy << " GeV. ";
             }
             DetId id_ = (*posCurrent).first;
             const CaloSubdetectorGeometry* geo = geometry->getSubdetectorGeometry(id_);
             auto this_cell = geo->getGeometry(id_);
             const GlobalPoint& cellPos = this_cell->getPosition();
             CLHEP::Hep3Vector gblPos (cellPos.x(),cellPos.y(),cellPos.z()); //surface position?
             // Evaluate the distance from the cluster centroid
             CLHEP::Hep3Vector diff = gblPos - clVect;
             // Important: for the moment calculation, only the "lateral distance" is important
             // "lateral distance" r_i = distance of the digi position from the axis Origin-Cluster Center
             // ---> subtract the projection on clDir
             CLHEP::Hep3Vector DigiVect = diff - diff.dot(clDir)*clDir;
             clEdep.r = DigiVect.mag();
             LogDebug("ClusterShapeAlgo") << "E = " << clEdep.deposited_energy
                 << "\tdiff = " << diff.mag()
                 << "\tr = " << clEdep.r;
             clEdep.phi = DigiVect.angle(theta_axis);
             if(DigiVect.dot(phi_axis)<0) clEdep.phi = 2 * M_PI - clEdep.phi;
             energyDistribution.push_back(clEdep);
         }
     }
     return energyDistribution;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getFraction	(	const std::vector< std::pair< DetId, float > > &	v_id,
		DetId	id
	)

static

Definition at line 259 of file EcalClusterTools.h.

References plotBeamSpotDB::first, DivergingColor::frac, and mps_fire::i.

 {
   if(noZS) return 1.0;
   float frac = 0.0;
   for ( size_t i = 0; i < v_id.size(); ++i ) {
     if(v_id[i].first.rawId()==id.rawId()){
       frac= v_id[i].second;
       break;
     }
   }
   return frac;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getIEta ( const DetId & id )

staticprivate

Definition at line 1030 of file EcalClusterTools.h.

References DetId::Ecal, EcalBarrel, EcalEndcap, EBDetId::ieta(), and mathSSE::sqrt().

 {
     if(id.det()==DetId::Ecal){
         if(id.subdetId()==EcalBarrel){
             EBDetId ebId(id);
             return ebId.ieta();
         }else if(id.subdetId()==EcalEndcap){
             float iXNorm = getNormedIX(id);
             float iYNorm = getNormedIY(id);
 
             return std::sqrt(iXNorm*iXNorm+iYNorm*iYNorm);
         }
     }
     return 0.;    
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getIPhi ( const DetId & id )

staticprivate

Definition at line 1052 of file EcalClusterTools.h.

References DetId::Ecal, EcalBarrel, and EBDetId::iphi().

 {
     if(id.det()==DetId::Ecal){
         if(id.subdetId()==EcalBarrel){
             EBDetId ebId(id);
             return ebId.iphi();
         }
     }
     return 0.;    
 }

template<bool noZS>

std::pair< DetId, float > EcalClusterToolsT< noZS >::getMaximum	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits
	)

static

Definition at line 288 of file EcalClusterTools.h.

 {
     return getMaximum( cluster.hitsAndFractions(), recHits );
 }

template<bool noZS>

std::pair< DetId, float > EcalClusterToolsT< noZS >::getMaximum	(	const std::vector< std::pair< DetId, float > > &	v_id,
		const EcalRecHitCollection *	recHits
	)

static

Definition at line 273 of file EcalClusterTools.h.

References plotBeamSpotDB::first, mps_fire::i, triggerObjects_cff::id, and SiStripPI::max.

 {
     float max = 0;
     DetId id(0);
     for ( size_t i = 0; i < v_id.size(); ++i ) {
       float energy = recHitEnergy( v_id[i].first, recHits ) * (noZS ? 1.0 : v_id[i].second);
         if ( energy > max ) {
             max = energy;
             id = v_id[i].first;
         }
     }
     return std::pair<DetId, float>(id, max);
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getNormedIX ( const DetId & id )

staticprivate

Definition at line 1065 of file EcalClusterTools.h.

References DetId::Ecal, EcalEndcap, and EEDetId::ix().

 {
     if(id.det()==DetId::Ecal && id.subdetId()==EcalEndcap){
         EEDetId eeId(id);      
         int iXNorm  = eeId.ix()-50;
         if(iXNorm<=0) iXNorm--;
         return iXNorm;
     }
     return 0;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getNormedIY ( const DetId & id )

staticprivate

Definition at line 1078 of file EcalClusterTools.h.

References DetId::Ecal, EcalEndcap, and EEDetId::iy().

 {
     if(id.det()==DetId::Ecal && id.subdetId()==EcalEndcap){
         EEDetId eeId(id);      
         int iYNorm  = eeId.iy()-50;
         if(iYNorm<=0) iYNorm--;
         return iYNorm;
     }
     return 0;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getNrCrysDiffInEta	(	const DetId &	crysId,
		const DetId &	orginId
	)

staticprivate

Definition at line 1091 of file EcalClusterTools.h.

References EcalBarrel, GeomDetEnumerators::isBarrel(), and DetId::subdetId().

 {
     float crysIEta = getIEta(crysId);
     float orginIEta = getIEta(orginId);
     bool isBarrel = orginId.subdetId()==EcalBarrel;
 
     float nrCrysDiff = crysIEta-orginIEta;
 
     //no iEta=0 in barrel, so if go from positive to negative
     //need to reduce abs(detEta) by 1
     if(isBarrel){ 
         if(crysIEta*orginIEta<0){ // -1 to 1 transition
             if(crysIEta>0) nrCrysDiff--;
             else nrCrysDiff++;
         }
     }
     return nrCrysDiff;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getNrCrysDiffInPhi	(	const DetId &	crysId,
		const DetId &	orginId
	)

staticprivate

Definition at line 1112 of file EcalClusterTools.h.

References EcalBarrel, GeomDetEnumerators::isBarrel(), and DetId::subdetId().

 {
     float crysIPhi = getIPhi(crysId);
     float orginIPhi = getIPhi(orginId);
     bool isBarrel = orginId.subdetId()==EcalBarrel;
 
     float nrCrysDiff = crysIPhi-orginIPhi;
 
     if(isBarrel){ //if barrel, need to map into 0-180 
         if (nrCrysDiff > + 180) { nrCrysDiff = nrCrysDiff - 360; }
         if (nrCrysDiff < - 180) { nrCrysDiff = nrCrysDiff + 360; }
     }
     return nrCrysDiff;
 }

template<bool noZS>

std::vector< int > EcalClusterToolsT< noZS >::getSeedPosition ( const std::vector< std::pair< const EcalRecHit *, float > > & RH_ptrs )

staticprivate

Definition at line 1632 of file EcalClusterTools.h.

References EcalRecHit::detid(), and EcalRecHit::energy().

Referenced by EcalClusterToolsT< noZS >::roundnessBarrelSuperClustersUserExtended(), and EcalClusterToolsT< noZS >::roundnessSelectedBarrelRecHits().

                                                                                                                          {
     std::vector<int> seedPosition;
     float eSeedRH = 0;
     int iEtaSeedRH = 0;
     int iPhiSeedRH = 0;
 
     for(auto const& rhf : RH_ptrs_fracs) {
       const EcalRecHit* rh_ptr = rhf.first;
         //get iEta, iPhi
         EBDetId EBdetIdi( rh_ptr->detid() );
         float rh_energy = rh_ptr->energy() * (noZS ? 1.0 : rhf.second);
 
         if(eSeedRH < rh_energy){
             eSeedRH = rh_energy;
             iEtaSeedRH = EBdetIdi.ieta();
             iPhiSeedRH = EBdetIdi.iphi();
         }
 
     }// for loop
 
     seedPosition.push_back(iEtaSeedRH);
     seedPosition.push_back(iPhiSeedRH);
     return seedPosition;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::getSumEnergy ( const std::vector< std::pair< const EcalRecHit *, float > > & RH_ptrs_fracs )

staticprivate

Definition at line 1659 of file EcalClusterTools.h.

Referenced by EcalClusterToolsT< noZS >::cluster2ndMoments(), and EcalClusterToolsT< noZS >::roundnessSelectedBarrelRecHits().

                                                                                                              {
     float sumE = 0.;
     for( const auto& hAndF : RH_ptrs_fracs ) {
       sumE += hAndF.first->energy() * (noZS ? 1.0 : hAndF.second);
     }
     return sumE;
 }

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::lat	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloGeometry *	geometry,
		bool	logW = `true`,
		float	w0 = `4.7`
	)

static

Definition at line 640 of file EcalClusterTools.h.

References funct::cos(), mps_fire::i, gen::n, phi, alignCSCRings::r, funct::sin(), and tmp.

 {
     std::vector<EcalClusterToolsT::EcalClusterEnergyDeposition> energyDistribution = getEnergyDepTopology( cluster, recHits, geometry, logW, w0 );
 
     std::vector<float> lat;
     double r, redmoment=0;
     double phiRedmoment = 0 ;
     double etaRedmoment = 0 ;
     int n,n1,n2,tmp;
     int clusterSize=energyDistribution.size();
     float etaLat_, phiLat_, lat_;
     if (clusterSize<3) {
         etaLat_ = 0.0 ;
         lat_ = 0.0;
         lat.push_back(0.);
         lat.push_back(0.);
         lat.push_back(0.);
         return lat; 
     }
 
     n1=0; n2=1;
     if (energyDistribution[1].deposited_energy > 
             energyDistribution[0].deposited_energy) 
     {
         tmp=n2; n2=n1; n1=tmp;
     }
     for (int i=2; i<clusterSize; i++) {
         n=i;
         if (energyDistribution[i].deposited_energy > 
                 energyDistribution[n1].deposited_energy) 
         {
             tmp = n2;
             n2 = n1; n1 = i; n=tmp;
         } else {
             if (energyDistribution[i].deposited_energy > 
                     energyDistribution[n2].deposited_energy) 
             {
                 tmp=n2; n2=i; n=tmp;
             }
         }
 
         r = energyDistribution[n].r;
         redmoment += r*r* energyDistribution[n].deposited_energy;
         double rphi = r * cos (energyDistribution[n].phi) ;
         phiRedmoment += rphi * rphi * energyDistribution[n].deposited_energy;
         double reta = r * sin (energyDistribution[n].phi) ;
         etaRedmoment += reta * reta * energyDistribution[n].deposited_energy;
     } 
     double e1 = energyDistribution[n1].deposited_energy;
     double e2 = energyDistribution[n2].deposited_energy;
 
     lat_ = redmoment/(redmoment+2.19*2.19*(e1+e2));
     phiLat_ = phiRedmoment/(phiRedmoment+2.19*2.19*(e1+e2));
     etaLat_ = etaRedmoment/(etaRedmoment+2.19*2.19*(e1+e2));
 
     lat.push_back(etaLat_);
     lat.push_back(phiLat_);
     lat.push_back(lat_);
     return lat;
 }

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::localCovariances	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology,
		float	w0 = `4.7`
	)

static

Definition at line 858 of file EcalClusterTools.h.

References pfDeepCMVADiscriminatorsJetTags_cfi::denominator, particleFlow_cfi::dEta, particleFlow_cfi::dPhi, EcalBarrel, f, DivergingColor::frac, GeomDetEnumerators::isBarrel(), cmsBatch::log, SiStripPI::max, DetId::subdetId(), findQualityFiles::v, and w.

Referenced by GsfElectronFull5x5Filler::calculateShowerShape_full5x5(), PhotonProducer::fillPhotonCollection(), and GEDPhotonProducer::fillPhotonCollection().

 {
 
     float e_5x5 = e5x5( cluster, recHits, topology );
     float covEtaEta, covEtaPhi, covPhiPhi;
 
     if (e_5x5 >= 0.) {
         //double w0_ = parameterMap_.find("W0")->second;
         const std::vector< std::pair<DetId, float> >& v_id = cluster.hitsAndFractions();
         std::pair<float,float> mean5x5PosInNrCrysFromSeed =  mean5x5PositionInLocalCrysCoord( cluster, recHits, topology );
         std::pair<float,float> mean5x5XYPos =  mean5x5PositionInXY(cluster,recHits,topology);
 
         // now we can calculate the covariances
         double numeratorEtaEta = 0;
         double numeratorEtaPhi = 0;
         double numeratorPhiPhi = 0;
         double denominator     = 0;
 
         //these allow us to scale the localCov by the crystal size 
         //so that the localCovs have the same average value as the normal covs
         const double barrelCrysSize = 0.01745; //approximate size of crystal in eta,phi in barrel
         const double endcapCrysSize = 0.0447; //the approximate crystal size sigmaEtaEta was corrected to in the endcap
 
         DetId seedId = getMaximum( v_id, recHits ).first;
 
         bool isBarrel=seedId.subdetId()==EcalBarrel;
         const double crysSize = isBarrel ? barrelCrysSize : endcapCrysSize;
 
         CaloRectangle rectangle{-2, 2, -2, 2};
         for (auto const& detId : rectangle(seedId, *topology)) {
             float frac = getFraction(v_id,detId);
             float energy = recHitEnergy( detId, recHits )*frac;
             if ( energy <= 0 ) continue;
 
             float dEta = getNrCrysDiffInEta(detId,seedId) - mean5x5PosInNrCrysFromSeed.first;
             float dPhi = 0;
 
             if(isBarrel)  dPhi = getNrCrysDiffInPhi(detId,seedId) - mean5x5PosInNrCrysFromSeed.second;
             else dPhi = getDPhiEndcap(detId,mean5x5XYPos.first,mean5x5XYPos.second);
 
 
             double w = std::max(0.0f,w0 + std::log( energy / e_5x5 ));
 
             denominator += w;
             numeratorEtaEta += w * dEta * dEta;
             numeratorEtaPhi += w * dEta * dPhi;
             numeratorPhiPhi += w * dPhi * dPhi;
         }
 
 
         //multiplying by crysSize to make the values compariable to normal covariances
         if (denominator != 0.0) {
             covEtaEta =  crysSize*crysSize* numeratorEtaEta / denominator;
             covEtaPhi =  crysSize*crysSize* numeratorEtaPhi / denominator;
             covPhiPhi =  crysSize*crysSize* numeratorPhiPhi / denominator;
         } else {
             covEtaEta = 999.9;
             covEtaPhi = 999.9;
             covPhiPhi = 999.9;
         }
 
 
     } else {
         // Warn the user if there was no energy in the cells and return zeroes.
         //       std::cout << "\ClusterShapeAlgo::Calculate_Covariances:  no energy in supplied cells.\n";
         covEtaEta = 0;
         covEtaPhi = 0;
         covPhiPhi = 0;
     }
     std::vector<float> v;
     v.push_back( covEtaEta );
     v.push_back( covEtaPhi );
     v.push_back( covPhiPhi );
     return v;
 }

template<bool noZS>

std::vector< DetId > EcalClusterToolsT< noZS >::matrixDetId	(	const CaloTopology *	topology,
		DetId	id,
		CaloRectangle	rectangle
	)

static

Definition at line 357 of file EcalClusterTools.h.

References findQualityFiles::v.

 {
     std::vector<DetId> v;
     for (auto const& detId : rectangle(id, *topology)) {
         if ( detId != DetId(0) ) v.push_back(detId);
     }
     return v;
 }

template<bool noZS>

static std::vector<DetId> EcalClusterToolsT< noZS >::matrixDetId	(	const CaloTopology *	topology,
		DetId	id,
		int	size
	)

inlinestatic

Definition at line 175 of file EcalClusterTools.h.

References findQualityFiles::size.

176 { return matrixDetId(topology, id, CaloRectangle{-size, size, -size, size}); }

findQualityFiles.size

size

Write out results.

Definition: findQualityFiles.py:443

EcalClusterToolsT::matrixDetId

static std::vector< DetId > matrixDetId(const CaloTopology *topology, DetId id, CaloRectangle rectangle)

Definition: EcalClusterTools.h:357

CaloRectangle

Definition: CaloRectangle.h:13

template<bool noZS>

float EcalClusterToolsT< noZS >::matrixEnergy	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology,
		DetId	id,
		CaloRectangle	rectangle
	)

static

Definition at line 330 of file EcalClusterTools.h.

 {
     float energy = 0;
     auto const& vId = cluster.hitsAndFractions();
 
     for (auto const& detId : rectangle(id, *topology)) {
         energy += recHitEnergy( detId, recHits ) * getFraction(vId, detId);
     }
 
     return energy;
 }

template<bool noZS>

int EcalClusterToolsT< noZS >::matrixSize	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology,
		DetId	id,
		CaloRectangle	rectangle
	)

static

Definition at line 343 of file EcalClusterTools.h.

References DivergingColor::frac, and mps_fire::result.

 {
     int result = 0;
 
     for (auto const& detId : rectangle(id, *topology)) {
         const float energy = recHitEnergy(detId, recHits);
         const float frac = getFraction(cluster.hitsAndFractions(), detId);
         if(energy * frac > 0) result++;
     }
     return result;
 }

template<bool noZS>

std::pair< float, float > EcalClusterToolsT< noZS >::mean5x5PositionInLocalCrysCoord	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

staticprivate

Definition at line 729 of file EcalClusterTools.h.

References CastorDataFrameFilter_impl::energySum().

 {
     DetId seedId =  getMaximum( cluster, recHits ).first;
     float meanDEta=0.;
     float meanDPhi=0.;
     float energySum=0.;
 
     const std::vector<std::pair<DetId,float> >& hsAndFs = cluster.hitsAndFractions();
     std::vector<DetId> v_id = matrixDetId( topology,seedId, 2 );
     for( const std::pair<DetId,float>& hAndF : hsAndFs ) {
       for ( std::vector<DetId>::const_iterator it = v_id.begin(); it != v_id.end(); ++it ) {
         if( hAndF.first != *it && !noZS ) continue;
         float energy = recHitEnergy(*it,recHits) * hAndF.second;
         if(energy<0.) continue;//skipping negative energy crystals
         meanDEta += energy * getNrCrysDiffInEta(*it,seedId);
         meanDPhi += energy * getNrCrysDiffInPhi(*it,seedId);
         energySum +=energy;
       }
       if(noZS) break;
     }
     meanDEta /=energySum;
     meanDPhi /=energySum;
     return std::pair<float,float>(meanDEta,meanDPhi);
 }

template<bool noZS>

std::pair< float, float > EcalClusterToolsT< noZS >::mean5x5PositionInXY	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

staticprivate

Definition at line 761 of file EcalClusterTools.h.

References EcalBarrel, CastorDataFrameFilter_impl::energySum(), and DetId::subdetId().

 {
     DetId seedId =  getMaximum( cluster, recHits ).first;
 
     std::pair<float,float> meanXY(0.,0.);
     if(seedId.subdetId()==EcalBarrel) return meanXY;
 
     float energySum=0.;
 
     const std::vector<std::pair<DetId,float> >& hsAndFs = cluster.hitsAndFractions();
     std::vector<DetId> v_id = matrixDetId( topology,seedId, 2);
     for( const std::pair<DetId,float>& hAndF : hsAndFs ) {
       for ( std::vector<DetId>::const_iterator it = v_id.begin(); it != v_id.end(); ++it ) {  
         if( hAndF.first != *it && !noZS) continue;
         float energy = recHitEnergy(*it,recHits) * hAndF.second;
         if(energy<0.) continue;//skipping negative energy crystals
         meanXY.first += energy * getNormedIX(*it);
         meanXY.second += energy * getNormedIY(*it);
         energySum +=energy;
       }
       if(noZS) break;
     }
     meanXY.first/=energySum;
     meanXY.second/=energySum;
     return meanXY;
 }

template<bool noZS>

math::XYZVector EcalClusterToolsT< noZS >::meanClusterPosition	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology,
		const CaloGeometry *	geometry
	)

staticprivate

Definition at line 702 of file EcalClusterTools.h.

References plotBeamSpotDB::first, CaloSubdetectorGeometry::getGeometry(), CaloGeometry::getSubdetectorGeometry(), position, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

 {
     // find mean energy position of a 5x5 cluster around the maximum
     math::XYZVector meanPosition(0.0, 0.0, 0.0);
     const std::vector<std::pair<DetId,float> >& hsAndFs = cluster.hitsAndFractions();
     std::vector<DetId> v_id = matrixDetId( topology, getMaximum( cluster, recHits ).first, 2 );
     for( const std::pair<DetId,float>& hitAndFrac : hsAndFs ) {
       for( std::vector<DetId>::const_iterator it = v_id.begin(); it != v_id.end(); ++it ) {
         if( hitAndFrac.first != *it && !noZS) continue;
         const CaloSubdetectorGeometry* geo = geometry->getSubdetectorGeometry(*it);
         GlobalPoint positionGP = geo->getGeometry( *it )->getPosition();
         math::XYZVector position(positionGP.x(),positionGP.y(),positionGP.z());
         meanPosition = meanPosition + recHitEnergy( *it, recHits ) * position * hitAndFrac.second;
       }
       if(noZS) break;
     }
     return meanPosition / e5x5( cluster, recHits, topology );
 }

template<bool noZS>

int EcalClusterToolsT< noZS >::n5x5	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 416 of file EcalClusterTools.h.

References plotBeamSpotDB::first.

 {
     DetId id = getMaximum( cluster.hitsAndFractions(), recHits ).first;
     return matrixSize( cluster, recHits, topology, id, {-2, 2, -2, 2} );
 }

template<bool noZS>

int EcalClusterToolsT< noZS >::nrSaturatedCrysIn5x5	(	const DetId &	id,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology
	)

static

Definition at line 1591 of file EcalClusterTools.h.

References edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), and EcalRecHit::kSaturated.

Referenced by ElectronHEEPIDValueMapProducer::nrSaturatedCrysIn5x5().

 {
     int nrSat=0;
     CaloRectangle rectangle{-2, 2, -2, 2};
     for (auto const& detId : rectangle(id, *topology)) {
         auto recHitIt = recHits->find(detId);
         if(recHitIt!=recHits->end() && recHitIt->checkFlag(EcalRecHit::kSaturated)) {
             nrSat++;
         }
     }
     return nrSat;
 }

template<bool noZS>

float EcalClusterToolsT< noZS >::recHitEnergy	(	DetId	id,
		const EcalRecHitCollection *	recHits
	)

static

Definition at line 295 of file EcalClusterTools.h.

References EcalBarrel, edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), EcalRecHit::kDiWeird, EcalRecHit::kTowerRecovered, and EcalRecHit::kWeird.

 {
   if ( id == DetId(0) ) {
     return 0;
   } else {
     EcalRecHitCollection::const_iterator it = recHits->find( id );
     if ( it != recHits->end() ) {
       if( noZS && ( it->checkFlag(EcalRecHit::kTowerRecovered) ||
                     it->checkFlag(EcalRecHit::kWeird) ||
                    (it->detid().subdetId() == EcalBarrel && 
                     it->checkFlag(EcalRecHit::kDiWeird) ))) return 0.0;
       else return it->energy();
     } else {
       //throw cms::Exception("EcalRecHitNotFound") << "The recHit corresponding to the DetId" << id.rawId() << " not found in the EcalRecHitCollection";
       // the recHit is not in the collection (hopefully zero suppressed)
       return 0;
     }
   }
   return 0;
 }

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::roundnessBarrelSuperClusters	(	const reco::SuperCluster &	superCluster,
		const EcalRecHitCollection &	recHits,
		int	weightedPositionMethod = `0`,
		float	energyThreshold = `0.0`
	)

static

Definition at line 1393 of file EcalClusterTools.h.

References edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), plotBeamSpotDB::first, reco::CaloCluster::hitsAndFractions(), mps_fire::i, EcalClusterToolsT< noZS >::roundnessSelectedBarrelRecHits(), edm::second(), and groupFilesInBlocks::temp.

                                                                                                                                                                                                    {//int positionWeightingMethod=0){
   std::vector<std::pair<const EcalRecHit*, float> > RH_ptrs_fracs;
     const std::vector< std::pair<DetId, float> >& myHitsPair = superCluster.hitsAndFractions();    
     for(unsigned int i=0; i< myHitsPair.size(); ++i){
         //get pointer to recHit object
         EcalRecHitCollection::const_iterator myRH = recHits.find(myHitsPair[i].first);
         if( myRH != recHits.end() && myRH->energy()*(noZS ? 1.0 : myHitsPair[i].second) > energyThreshold){ 
             //require rec hit to have positive energy
             RH_ptrs_fracs.push_back(  std::make_pair(&(*myRH) , myHitsPair[i].second)  );
         }
     }
     std::vector<float> temp = EcalClusterToolsT<noZS>::roundnessSelectedBarrelRecHits(RH_ptrs_fracs,weightedPositionMethod); 
     return temp;
 }

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::roundnessBarrelSuperClustersUserExtended	(	const reco::SuperCluster &	superCluster,
		const EcalRecHitCollection &	recHits,
		int	ieta_delta = `0`,
		int	iphi_delta = `0`,
		float	energyRHThresh = `0.00000`,
		int	weightedPositionMethod = `0`
	)

static

Definition at line 1413 of file EcalClusterTools.h.

References funct::abs(), edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), plotBeamSpotDB::first, EcalClusterToolsT< noZS >::getSeedPosition(), reco::CaloCluster::hitsAndFractions(), mps_fire::i, EcalClusterToolsT< noZS >::roundnessSelectedBarrelRecHits(), and edm::second().

                                                                                                                                                                                                                                               {
 
   std::vector<std::pair<const EcalRecHit*, float> > RH_ptrs_fracs;
     const std::vector< std::pair<DetId, float> >& myHitsPair = superCluster.hitsAndFractions();
     for(unsigned int i=0; i<myHitsPair.size(); ++i){
         //get pointer to recHit object
         EcalRecHitCollection::const_iterator myRH = recHits.find(myHitsPair[i].first);
         if(myRH != recHits.end() && myRH->energy()*(noZS ? 1.0 : myHitsPair[i].second) > energyRHThresh)
             RH_ptrs_fracs.push_back(  std::make_pair(&(*myRH) , myHitsPair[i].second) );
     }
 
 
     std::vector<int> seedPosition = EcalClusterToolsT<noZS>::getSeedPosition(  RH_ptrs_fracs  );
 
     for(EcalRecHitCollection::const_iterator rh = recHits.begin(); rh != recHits.end(); rh++){
         EBDetId EBdetIdi( rh->detid() );
         float the_fraction = 0;
         //if(rh != recHits.end())
         bool inEtaWindow = (   abs(  deltaIEta(seedPosition[0],EBdetIdi.ieta())  ) <= ieta_delta   );
         bool inPhiWindow = (   abs(  deltaIPhi(seedPosition[1],EBdetIdi.iphi())  ) <= iphi_delta   );
         bool passEThresh = (  rh->energy() > energyRHThresh  );
         bool alreadyCounted = false;
 
         // figure out if the rechit considered now is already inside the SC
         bool is_SCrh_inside_recHits = false;
         for(unsigned int i=0; i<myHitsPair.size(); i++){
             EcalRecHitCollection::const_iterator SCrh = recHits.find(myHitsPair[i].first);
             if(SCrh != recHits.end()){
                 the_fraction = myHitsPair[i].second;
                 is_SCrh_inside_recHits = true;
                 if( rh->detid() == SCrh->detid()  ) alreadyCounted = true;
             }
         }//for loop over SC's recHits
 
         if( is_SCrh_inside_recHits && !alreadyCounted && passEThresh && inEtaWindow && inPhiWindow){
             RH_ptrs_fracs.push_back( std::make_pair(&(*rh),the_fraction) );
         }
 
     }//for loop over rh
     return EcalClusterToolsT<noZS>::roundnessSelectedBarrelRecHits(RH_ptrs_fracs,weightedPositionMethod);
 }

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::roundnessSelectedBarrelRecHits	(	const std::vector< std::pair< const EcalRecHit *, float > > &	rhVector,
		int	weightedPositionMethod = `0`
	)

static

Definition at line 1459 of file EcalClusterTools.h.

References funct::abs(), pfDeepCMVADiscriminatorsJetTags_cfi::denominator, EcalRecHit::detid(), EcalRecHit::energy(), EcalClusterToolsT< noZS >::getSeedPosition(), EcalClusterToolsT< noZS >::getSumEnergy(), mps_fire::i, cmsBatch::log, SiStripPI::max, groupFilesInBlocks::temp, and mps_merge::weight.

Referenced by EcalClusterToolsT< noZS >::roundnessBarrelSuperClusters(), and EcalClusterToolsT< noZS >::roundnessBarrelSuperClustersUserExtended().

                                                                                                                                                                       {//int weightedPositionMethod = 0){
     //positionWeightingMethod = 0 linear weighting, 1 log energy weighting
 
     std::vector<float> shapes; // this is the returning vector
 
     //make sure photon has more than one crystal; else roundness and angle suck
     if(RH_ptrs_fracs.size()<2){
         shapes.push_back( -3 );
         shapes.push_back( -3 );
         return shapes;
     }
 
     //Find highest E RH (Seed) and save info, compute sum total energy used
     std::vector<int> seedPosition = EcalClusterToolsT<noZS>::getSeedPosition(  RH_ptrs_fracs  );// *recHits);
     int tempInt = seedPosition[0];
     if(tempInt <0) tempInt++;
     float energyTotal = EcalClusterToolsT<noZS>::getSumEnergy(  RH_ptrs_fracs  );
 
     //1st loop over rechits: compute new weighted center position in coordinates centered on seed
     float centerIEta = 0.;
     float centerIPhi = 0.;
     float denominator = 0.;
 
     for(std::vector<std::pair<const EcalRecHit*,float> >::const_iterator rhf_ptr = RH_ptrs_fracs.begin(); rhf_ptr != RH_ptrs_fracs.end(); rhf_ptr++){
         const EcalRecHit* rh_ptr = rhf_ptr->first;
         //get iEta, iPhi
         EBDetId EBdetIdi( rh_ptr->detid() );
         if(fabs(energyTotal) < 0.0001){
             // don't /0, bad!
             shapes.push_back( -2 );
             shapes.push_back( -2 );
             return shapes;
         }
         float rh_energy = rh_ptr->energy() * (noZS ? 1.0 : rhf_ptr->second);
         float weight = 0;
         if(std::abs(weightedPositionMethod)<0.0001){ //linear
             weight = rh_energy/energyTotal;
         }else{ //logrithmic
             weight = std::max(0.0, 4.2 + log(rh_energy/energyTotal));
         }
         denominator += weight;
         centerIEta += weight*deltaIEta(seedPosition[0],EBdetIdi.ieta());
         centerIPhi += weight*deltaIPhi(seedPosition[1],EBdetIdi.iphi());
     }
     if(fabs(denominator) < 0.0001){
         // don't /0, bad!
         shapes.push_back( -2 );
         shapes.push_back( -2 );
         return shapes;
     }
     centerIEta = centerIEta / denominator;
     centerIPhi = centerIPhi / denominator;
 
 
     //2nd loop over rechits: compute inertia tensor
     TMatrixDSym inertia(2); //initialize 2d inertia tensor
     double inertia00 = 0.;
     double inertia01 = 0.;// = inertia10 b/c matrix should be symmetric
     double inertia11 = 0.;
     int i = 0;
     for(std::vector<std::pair<const EcalRecHit*,float> >::const_iterator rhf_ptr = RH_ptrs_fracs.begin(); rhf_ptr != RH_ptrs_fracs.end(); rhf_ptr++){
       const EcalRecHit* rh_ptr = rhf_ptr->first;
         //get iEta, iPhi
         EBDetId EBdetIdi( rh_ptr->detid() );
 
         if(fabs(energyTotal) < 0.0001){
             // don't /0, bad!
             shapes.push_back( -2 );
             shapes.push_back( -2 );
             return shapes;
         }
         float rh_energy = rh_ptr->energy() * (noZS ? 1.0 : rhf_ptr->second);
         float weight = 0;
         if(std::abs(weightedPositionMethod) < 0.0001){ //linear
             weight = rh_energy/energyTotal;
         }else{ //logrithmic
             weight = std::max(0.0, 4.2 + log(rh_energy/energyTotal));
         }
 
         float ieta_rh_to_center = deltaIEta(seedPosition[0],EBdetIdi.ieta()) - centerIEta;
         float iphi_rh_to_center = deltaIPhi(seedPosition[1],EBdetIdi.iphi()) - centerIPhi;
 
         inertia00 += weight*iphi_rh_to_center*iphi_rh_to_center;
         inertia01 -= weight*iphi_rh_to_center*ieta_rh_to_center;
         inertia11 += weight*ieta_rh_to_center*ieta_rh_to_center;
         i++;
     }
 
     inertia[0][0] = inertia00;
     inertia[0][1] = inertia01; // use same number here
     inertia[1][0] = inertia01; // and here to insure symmetry
     inertia[1][1] = inertia11;
 
 
     //step 1 find principal axes of inertia
     TMatrixD eVectors(2,2);
     TVectorD eValues(2);
     //std::cout<<"EcalClusterToolsT<noZS>::showerRoundness- about to compute eVectors"<<std::endl;
     eVectors=inertia.EigenVectors(eValues); //ordered highest eV to lowest eV (I checked!)
     //and eVectors are in columns of matrix! I checked!
     //and they are normalized to 1
 
 
 
     //step 2 select eta component of smaller eVal's eVector
     TVectorD smallerAxis(2);//easiest to spin SC on this axis (smallest eVal)
     smallerAxis[0]=eVectors[0][1];//row,col  //eta component
     smallerAxis[1]=eVectors[1][1];           //phi component
 
     //step 3 compute interesting quatities
     Double_t temp = fabs(smallerAxis[0]);// closer to 1 ->beamhalo, closer to 0 something else
     if(fabs(eValues[0]) < 0.0001){
         // don't /0, bad!
         shapes.push_back( -2 );
         shapes.push_back( -2 );
         return shapes;
     }
 
     float Roundness = eValues[1]/eValues[0];
     float Angle=acos(temp);
 
     if( -0.00001 < Roundness && Roundness < 0) Roundness = 0.;
     if( -0.00001 < Angle && Angle < 0 ) Angle = 0.;
 
     shapes.push_back( Roundness );
     shapes.push_back( Angle );
     return shapes;
 
 }

template<bool noZS>

std::vector< float > EcalClusterToolsT< noZS >::scLocalCovariances	(	const reco::SuperCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloTopology *	topology,
		float	w0 = `4.7`
	)

static

Definition at line 1150 of file EcalClusterTools.h.

References pfDeepCMVADiscriminatorsJetTags_cfi::denominator, particleFlow_cfi::dEta, particleFlow_cfi::dPhi, EcalBarrel, f, plotBeamSpotDB::first, DivergingColor::frac, reco::CaloCluster::hitsAndFractions(), mps_fire::i, GeomDetEnumerators::isBarrel(), cmsBatch::log, SiStripPI::max, reco::SuperCluster::seed(), DetId::subdetId(), findQualityFiles::v, and w.

 {
     const reco::BasicCluster bcluster = *(cluster.seed());
 
     float e_5x5 = e5x5(bcluster, recHits, topology);
     float covEtaEta, covEtaPhi, covPhiPhi;
 
     if (e_5x5 >= 0.) {
         const std::vector<std::pair<DetId, float> >& v_id = cluster.hitsAndFractions();
         std::pair<float,float> mean5x5PosInNrCrysFromSeed =  mean5x5PositionInLocalCrysCoord(bcluster, recHits, topology);
         std::pair<float,float> mean5x5XYPos =  mean5x5PositionInXY(cluster,recHits,topology);
         // now we can calculate the covariances
         double numeratorEtaEta = 0;
         double numeratorEtaPhi = 0;
         double numeratorPhiPhi = 0;
         double denominator     = 0;
 
         const double barrelCrysSize = 0.01745; //approximate size of crystal in eta,phi in barrel
         const double endcapCrysSize = 0.0447; //the approximate crystal size sigmaEtaEta was corrected to in the endcap
 
         DetId seedId = getMaximum(v_id, recHits).first;  
         bool isBarrel=seedId.subdetId()==EcalBarrel;
 
         const double crysSize = isBarrel ? barrelCrysSize : endcapCrysSize;
 
         for (size_t i = 0; i < v_id.size(); ++i) {
             float frac = getFraction(v_id, v_id[i].first);
             float energy = recHitEnergy(v_id[i].first, recHits)*frac;
 
             if (energy <= 0) continue;
 
             float dEta = getNrCrysDiffInEta(v_id[i].first,seedId) - mean5x5PosInNrCrysFromSeed.first;
             float dPhi = 0;
             if(isBarrel)  dPhi = getNrCrysDiffInPhi(v_id[i].first,seedId) - mean5x5PosInNrCrysFromSeed.second;
             else dPhi = getDPhiEndcap(v_id[i].first,mean5x5XYPos.first,mean5x5XYPos.second);
 
 
 
             double w = 0.;
             w = std::max(0.0f, w0 + std::log( energy / e_5x5 ));
 
             denominator += w;
             numeratorEtaEta += w * dEta * dEta;
             numeratorEtaPhi += w * dEta * dPhi;
             numeratorPhiPhi += w * dPhi * dPhi;
         }
 
         //multiplying by crysSize to make the values compariable to normal covariances
         if (denominator != 0.0) {
             covEtaEta =  crysSize*crysSize* numeratorEtaEta / denominator;
             covEtaPhi =  crysSize*crysSize* numeratorEtaPhi / denominator;
             covPhiPhi =  crysSize*crysSize* numeratorPhiPhi / denominator;
         } else {
             covEtaEta = 999.9;
             covEtaPhi = 999.9;
             covPhiPhi = 999.9;
         }
 
     } else {
         // Warn the user if there was no energy in the cells and return zeroes.
         // std::cout << "\ClusterShapeAlgo::Calculate_Covariances:  no energy in supplied cells.\n";
         covEtaEta = 0;
         covEtaPhi = 0;
         covPhiPhi = 0;
     }
 
     std::vector<float> v;
     v.push_back( covEtaEta );
     v.push_back( covEtaPhi );
     v.push_back( covPhiPhi );
 
     return v;
 }

template<bool noZS>

double EcalClusterToolsT< noZS >::zernike20	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloGeometry *	geometry,
		double	R0 = `6.6`,
		bool	logW = `true`,
		float	w0 = `4.7`
	)

static

Definition at line 935 of file EcalClusterTools.h.

 {
     return absZernikeMoment( cluster, recHits, geometry, 2, 0, R0, logW, w0 );
 }

template<bool noZS>

double EcalClusterToolsT< noZS >::zernike42	(	const reco::BasicCluster &	cluster,
		const EcalRecHitCollection *	recHits,
		const CaloGeometry *	geometry,
		double	R0 = `6.6`,
		bool	logW = `true`,
		float	w0 = `4.7`
	)

static

Definition at line 941 of file EcalClusterTools.h.

 {
     return absZernikeMoment( cluster, recHits, geometry, 4, 2, R0, logW, w0 );
 }

Classes

Static Public Member Functions

Static Private Member Functions

Detailed Description

template<bool noZS> class EcalClusterToolsT< noZS >

Member Function Documentation

template<bool noZS>
class EcalClusterToolsT< noZS >