EcalClusterToolsT< noZS > Class Template Reference

#include <EcalClusterTools.h>

Classes
struct	EcalClusterEnergyDeposition

Public Member Functions
	EcalClusterToolsT ()
	~EcalClusterToolsT ()

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 std::vector< float >	covariances (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const CaloGeometry *geometry, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv, float w0=4.7)
static float	e1x3 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e1x3 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e1x5 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e1x5 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e2nd (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)
static float	e2nd (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e2x2 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e2x2 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e2x5Bottom (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e2x5Bottom (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e2x5Left (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e2x5Left (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e2x5Max (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e2x5Max (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e2x5Right (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e2x5Right (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e2x5Top (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e2x5Top (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e3x1 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e3x1 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e3x2 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e3x2 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e3x3 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e3x3 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e4x4 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e4x4 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e5x1 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e5x1 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	e5x5 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	e5x5 (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	eBottom (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	eBottom (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	eLeft (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	eLeft (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	eMax (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)
static float	eMax (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static std::vector< float >	energyBasketFractionEta (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)
static std::vector< float >	energyBasketFractionEta (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static std::vector< float >	energyBasketFractionPhi (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)
static std::vector< float >	energyBasketFractionPhi (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	eRight (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	eRight (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	eTop (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float	eTop (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
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 reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static std::pair< DetId, float >	getMaximum (const std::vector< std::pair< DetId, float > > &v_id, const EcalRecHitCollection *recHits)
static std::pair< DetId, float >	getMaximum (const std::vector< std::pair< DetId, float > > &v_id, const EcalRecHitCollection *recHits, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
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 >	lat (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloGeometry *geometry, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv, 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< float >	localCovariances (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv, float w0=4.7)
static std::vector< DetId >	matrixDetId (const CaloTopology *topology, DetId id, int ixMin, int ixMax, int iyMin, int iyMax)
static std::vector< DetId >	matrixDetId (const CaloTopology *topology, DetId id, int ixMin, int ixMax, int iyMin, int iyMax, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	matrixEnergy (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, DetId id, int ixMin, int ixMax, int iyMin, int iyMax)
static float	matrixEnergy (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, DetId id, int ixMin, int ixMax, int iyMin, int iyMax, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static float	recHitEnergy (DetId id, const EcalRecHitCollection *recHits)
static float	recHitEnergy (DetId id, const EcalRecHitCollection *recHits, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
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 std::vector< float >	scLocalCovariances (const reco::SuperCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv, 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 >	mean5x5PositionInLocalCrysCoord (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static std::pair< float, float >	mean5x5PositionInXY (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, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)
static math::XYZVector	meanClusterPosition (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const CaloGeometry *geometry)
static math::XYZVector	meanClusterPosition (const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const CaloGeometry *geometry, const std::vector< int > &flagsexcl, const std::vector< int > &severitiesexcl, const EcalSeverityLevelAlgo *sevLv)

Detailed Description

template<bool noZS>
class EcalClusterToolsT< noZS >

Definition at line 76 of file EcalClusterTools.h.

Constructor & Destructor Documentation

template<bool noZS>

EcalClusterToolsT< noZS >::EcalClusterToolsT ( )

inline

Definition at line 78 of file EcalClusterTools.h.

{};

template<bool noZS>

EcalClusterToolsT< noZS >::~EcalClusterToolsT ( )

inline

Definition at line 79 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 1494 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 1543 of file EcalClusterTools.h.

References funct::cos(), alignCSCRings::e, factorial(), i, m, funct::pow(), alignCSCRings::r, 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 1856 of file EcalClusterTools.h.

References edm::SortedCollection< T, SORT >::find(), first, i, and edm::second().

Referenced by EcalClusterToolsT< noZS >::cluster2ndMoments().

                                                                                                                                                                                                  {

  // for now implemented only for EB:
  //  if( fabs( basicCluster.eta() ) < 1.479 ) { 

  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);
    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 1875 of file EcalClusterTools.h.

References Cluster2ndMoments::alpha, EcalClusterToolsT< noZS >::cluster2ndMoments(), reco::SuperCluster::seed(), Cluster2ndMoments::sMaj, and Cluster2ndMoments::sMin.

                                                                                                                                                                                                  {

  // for now returns second moments of supercluster seed cluster:
  Cluster2ndMoments returnMoments;
  returnMoments.sMaj = -1.;
  returnMoments.sMin = -1.;
  returnMoments.alpha = 0.;

  // for now implemented only for EB:
  //  if( fabs( superCluster.eta() ) < 1.479 ) { 
    returnMoments = EcalClusterToolsT<noZS>::cluster2ndMoments( *(superCluster.seed()), recHits, phiCorrectionFactor, w0, useLogWeights);
    //  }

  return returnMoments;

}

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 1893 of file EcalClusterTools.h.

References funct::abs(), Cluster2ndMoments::alpha, cuy::denominator, CaloRecHit::detid(), EcalBarrel, CaloRecHit::energy(), EcalClusterToolsT< noZS >::getSumEnergy(), i, create_public_lumi_plots::log, max(), phi, Cluster2ndMoments::sMaj, Cluster2ndMoments::sMin, mathSSE::sqrt(), and DetId::subdetId().

                                                                                                                                                                                           {

  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(1);

  // 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 1175 of file EcalClusterTools.h.

References cuy::denominator, dPhi(), relval_parameters_module::energy, PV3DBase< T, PVType, FrameType >::eta(), f, cropTnPTrees::frac, CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), CaloGeometry::getSubdetectorGeometry(), CaloTopology::getSubdetectorTopology(), i, j, create_public_lumi_plots::log, max(), Geom::Phi< T >::phi(), PV3DBase< T, PVType, FrameType >::phi(), Geom::pi(), position, Geom::twoPi(), findQualityFiles::v, and w().

{
    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;
        CaloNavigator<DetId> cursor = CaloNavigator<DetId>( id, topology->getSubdetectorTopology( id ) );
        for ( int i = -2; i <= 2; ++i ) {
            for ( int j = -2; j <= 2; ++j ) {
                cursor.home();
                cursor.offsetBy( i, j );
                float frac=getFraction(v_id,*cursor);
                float energy = recHitEnergy( *cursor, recHits )*frac;

                if ( energy <= 0 ) continue;

                GlobalPoint position = geometry->getSubdetectorGeometry(*cursor)->getGeometry(*cursor)->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>

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

static

Definition at line 1244 of file EcalClusterTools.h.

References cuy::denominator, dPhi(), relval_parameters_module::energy, PV3DBase< T, PVType, FrameType >::eta(), f, cropTnPTrees::frac, CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), CaloGeometry::getSubdetectorGeometry(), CaloTopology::getSubdetectorTopology(), i, j, create_public_lumi_plots::log, max(), Geom::Phi< T >::phi(), PV3DBase< T, PVType, FrameType >::phi(), Geom::pi(), position, Geom::twoPi(), findQualityFiles::v, and w().

{
    float e_5x5 = e5x5( cluster, recHits, topology,flagsexcl, severitiesexcl, sevLv );
    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,flagsexcl, severitiesexcl, sevLv );

        // 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;
        CaloNavigator<DetId> cursor = CaloNavigator<DetId>( id, topology->getSubdetectorTopology( id ) );
        for ( int i = -2; i <= 2; ++i ) {
            for ( int j = -2; j <= 2; ++j ) {
                cursor.home();
                cursor.offsetBy( i, j );
                float frac = getFraction(v_id,*cursor);
                float energy = recHitEnergy( *cursor, recHits,flagsexcl, severitiesexcl, sevLv )*frac;

                if ( energy <= 0 ) continue;

                GlobalPoint position = geometry->getSubdetectorGeometry(*cursor)->getGeometry(*cursor)->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 2238 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 2226 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 741 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e1x3 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 748 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 712 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e1x5 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 719 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 589 of file EcalClusterTools.h.

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

{
    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 >::e2nd ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 605 of file EcalClusterTools.h.

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

{
    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,flagsexcl, severitiesexcl, sevLv ) * (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 479 of file EcalClusterTools.h.

References first, and max().

{
    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 >::e2x2 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 491 of file EcalClusterTools.h.

References first, and max().

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

template<bool noZS>

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

static

Definition at line 664 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Bottom ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 671 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 635 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Left ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 642 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 680 of file EcalClusterTools.h.

References first.

{
    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 >::e2x5Max ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 696 of file EcalClusterTools.h.

References first.

{
    DetId id =      getMaximum( cluster.hitsAndFractions(), recHits,flagsexcl, severitiesexcl, sevLv ).first;

    // 1x5 strip left of seed
    float left   = matrixEnergy( cluster, recHits, topology, id, -1, -1, -2, 2,flagsexcl, severitiesexcl, sevLv );
    // 1x5 strip right of seed
    float right  = matrixEnergy( cluster, recHits, topology, id,  1,  1, -2, 2,flagsexcl, severitiesexcl, sevLv );
    // 1x5 strip containing seed
    float centre = matrixEnergy( cluster, recHits, topology, id,  0,  0, -2, 2,flagsexcl, severitiesexcl, sevLv );

    // 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 621 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Right ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 628 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 650 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e2x5Top ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 657 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 755 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e3x1 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 762 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 502 of file EcalClusterTools.h.

References first, and 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 >::e3x2 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 513 of file EcalClusterTools.h.

References first, and max().

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

template<bool noZS>

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

static

Definition at line 525 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e3x3 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 532 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 539 of file EcalClusterTools.h.

References first, and 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 >::e4x4 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 550 of file EcalClusterTools.h.

References first, and max().

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

template<bool noZS>

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

static

Definition at line 727 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e5x1 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 734 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 563 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::e5x5 ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 570 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 811 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::eBottom ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 818 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 769 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::eLeft ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 776 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 577 of file EcalClusterTools.h.

References edm::second().

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

template<bool noZS>

float EcalClusterToolsT< noZS >::eMax ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 583 of file EcalClusterTools.h.

References edm::second().

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

template<bool noZS>

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

static

Definition at line 825 of file EcalClusterTools.h.

References EcalBarrel, first, i, EBDetId::im(), EBDetId::kModulesPerSM, EBDetId::positiveZ(), and python.multivaluedict::sort().

{
    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 >::energyBasketFractionEta ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 842 of file EcalClusterTools.h.

References EcalBarrel, first, i, EBDetId::im(), EBDetId::kModulesPerSM, EBDetId::positiveZ(), and python.multivaluedict::sort().

{
    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,flagsexcl, severitiesexcl, sevLv ) * (noZS ? 1.0 : 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 859 of file EcalClusterTools.h.

References EcalBarrel, first, i, EBDetId::iphi(), EBDetId::kCrystalsInPhi, EBDetId::kTowersInPhi, EBDetId::MAX_IPHI, EBDetId::positiveZ(), and python.multivaluedict::sort().

{
    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>

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

static

Definition at line 876 of file EcalClusterTools.h.

References EcalBarrel, first, i, EBDetId::iphi(), EBDetId::kCrystalsInPhi, EBDetId::kTowersInPhi, EBDetId::MAX_IPHI, EBDetId::positiveZ(), and python.multivaluedict::sort().

{
    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,flagsexcl, severitiesexcl, sevLv ) * (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 783 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::eRight ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 790 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

static

Definition at line 797 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

float EcalClusterToolsT< noZS >::eTop ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 804 of file EcalClusterTools.h.

References first.

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

template<bool noZS>

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

inlinestaticprivate

Definition at line 247 of file EcalClusterTools.h.

{ return 1; }

template<bool noZS>

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

inlinestaticprivate

Definition at line 248 of file EcalClusterTools.h.

References alignCSCRings::r.

{ return r; }

template<bool noZS>

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

inlinestaticprivate

Definition at line 249 of file EcalClusterTools.h.

{ return 2.0*r*r-1.0; }

template<bool noZS>

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

inlinestaticprivate

Definition at line 250 of file EcalClusterTools.h.

References alignCSCRings::r.

{ return r*r; }

template<bool noZS>

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

inlinestaticprivate

Definition at line 251 of file EcalClusterTools.h.

References alignCSCRings::r.

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

template<bool noZS>

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

inlinestaticprivate

Definition at line 252 of file EcalClusterTools.h.

References alignCSCRings::r.

{ return r*r*r; }

template<bool noZS>

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

inlinestaticprivate

Definition at line 253 of file EcalClusterTools.h.

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

template<bool noZS>

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

inlinestaticprivate

Definition at line 254 of file EcalClusterTools.h.

References alignCSCRings::r.

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

template<bool noZS>

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

inlinestaticprivate

Definition at line 255 of file EcalClusterTools.h.

References alignCSCRings::r.

{ return r*r*r*r; }

template<bool noZS>

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

inlinestaticprivate

Definition at line 256 of file EcalClusterTools.h.

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

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

template<bool noZS>

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

inlinestaticprivate

Definition at line 257 of file EcalClusterTools.h.

References funct::pow().

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

template<bool noZS>

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

inlinestaticprivate

Definition at line 258 of file EcalClusterTools.h.

References funct::pow().

{ return pow(r,5); }

template<bool noZS>

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

inlinestaticprivate

Definition at line 264 of file EcalClusterTools.h.

References i, and 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 1507 of file EcalClusterTools.h.

References funct::cos(), alignCSCRings::e, i, getHLTprescales::index, phi, alignCSCRings::r, 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 1676 of file EcalClusterTools.h.

References 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 893 of file EcalClusterTools.h.

References funct::abs(), EcalClusterToolsT< noZS >::EcalClusterEnergyDeposition::deposited_energy, diffTreeTool::diff, edm::SortedCollection< T, SORT >::end(), CaloRecHit::energy(), edm::SortedCollection< T, SORT >::find(), CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), CaloGeometry::getSubdetectorGeometry(), create_public_lumi_plots::log, LogDebug, M_PI, max(), EcalClusterToolsT< noZS >::EcalClusterEnergyDeposition::phi, EcalClusterToolsT< noZS >::EcalClusterEnergyDeposition::r, histoStyle::weight, 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 CaloCellGeometry *this_cell = geometry->getSubdetectorGeometry(id_)->getGeometry(id_);
            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 290 of file EcalClusterTools.h.

References first, cropTnPTrees::frac, and 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 1577 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 1599 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 334 of file EcalClusterTools.h.

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

template<bool noZS>

std::pair< DetId, float > EcalClusterToolsT< noZS >::getMaximum ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 340 of file EcalClusterTools.h.

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

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 304 of file EcalClusterTools.h.

References relval_parameters_module::energy, first, i, and 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>

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

static

Definition at line 319 of file EcalClusterTools.h.

References relval_parameters_module::energy, first, i, and 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,flagsexcl, severitiesexcl, sevLv ) * (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 1612 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 1625 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 1638 of file EcalClusterTools.h.

References EcalBarrel, 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 1659 of file EcalClusterTools.h.

References EcalBarrel, 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 2248 of file EcalClusterTools.h.

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

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

                                                                                                                         {
    std::vector<int> seedPosition;
    float eSeedRH = 0;
    int iEtaSeedRH = 0;
    int iPhiSeedRH = 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() );
    float rh_energy = rh_ptr->energy() * (noZS ? 1.0 : rhf_ptr->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 2275 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 953 of file EcalClusterTools.h.

References funct::cos(), reco::e1, reco::e2, i, 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>

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

static

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 1317 of file EcalClusterTools.h.

References cuy::denominator, dPhi(), EcalBarrel, relval_parameters_module::energy, f, cropTnPTrees::frac, CaloTopology::getSubdetectorTopology(), create_public_lumi_plots::log, max(), DetId::subdetId(), findQualityFiles::v, and w().

{

    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;

        CaloNavigator<DetId> cursor = CaloNavigator<DetId>( seedId, topology->getSubdetectorTopology( seedId ) );

        for ( int eastNr = -2; eastNr <= 2; ++eastNr ) { //east is eta in barrel
            for ( int northNr = -2; northNr <= 2; ++northNr ) { //north is phi in barrel
                cursor.home();
                cursor.offsetBy( eastNr, northNr);
                float frac = getFraction(v_id,*cursor);
                float energy = recHitEnergy( *cursor, recHits )*frac;
                if ( energy <= 0 ) continue;

                float dEta = getNrCrysDiffInEta(*cursor,seedId) - mean5x5PosInNrCrysFromSeed.first;
                float dPhi = 0;

                if(isBarrel)  dPhi = getNrCrysDiffInPhi(*cursor,seedId) - mean5x5PosInNrCrysFromSeed.second;
                else dPhi = getDPhiEndcap(*cursor,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;
            } //end east loop
        }//end north loop


        //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< float > EcalClusterToolsT< noZS >::localCovariances ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv, float  w0 = 4.7  )

static

Definition at line 1400 of file EcalClusterTools.h.

References cuy::denominator, dPhi(), EcalBarrel, relval_parameters_module::energy, f, cropTnPTrees::frac, CaloTopology::getSubdetectorTopology(), create_public_lumi_plots::log, max(), DetId::subdetId(), findQualityFiles::v, and w().

{

    float e_5x5 = e5x5( cluster, recHits, topology,flagsexcl, severitiesexcl, sevLv );
    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,flagsexcl, severitiesexcl, sevLv );
        std::pair<float,float> mean5x5XYPos =  mean5x5PositionInXY(cluster,recHits,topology,flagsexcl, severitiesexcl, sevLv);

        // 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;

        CaloNavigator<DetId> cursor = CaloNavigator<DetId>( seedId, topology->getSubdetectorTopology( seedId ) );

        for ( int eastNr = -2; eastNr <= 2; ++eastNr ) { //east is eta in barrel
            for ( int northNr = -2; northNr <= 2; ++northNr ) { //north is phi in barrel
                cursor.home();
                cursor.offsetBy( eastNr, northNr);
                float frac = getFraction(v_id,*cursor); 
                float energy = recHitEnergy( *cursor, recHits,flagsexcl, severitiesexcl, sevLv)*frac;
                if ( energy <= 0 ) continue;

                float dEta = getNrCrysDiffInEta(*cursor,seedId) - mean5x5PosInNrCrysFromSeed.first;
                float dPhi = 0;

                if(isBarrel)  dPhi = getNrCrysDiffInPhi(*cursor,seedId) - mean5x5PosInNrCrysFromSeed.second;
                else dPhi = getDPhiEndcap(*cursor,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;
            } //end east loop
        }//end north loop


        //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, int  ixMin, int  ixMax, int  iyMin, int  iyMax  )

static

Definition at line 463 of file EcalClusterTools.h.

References CaloTopology::getSubdetectorTopology(), i, j, and findQualityFiles::v.

{
    CaloNavigator<DetId> cursor = CaloNavigator<DetId>( id, topology->getSubdetectorTopology( id ) );
    std::vector<DetId> v;
    for ( int i = ixMin; i <= ixMax; ++i ) {
        for ( int j = iyMin; j <= iyMax; ++j ) {
            cursor.home();
            cursor.offsetBy( i, j );
            if ( *cursor != DetId(0) ) v.push_back( *cursor );
        }
    }
    return v;
}

template<bool noZS>

static std::vector<DetId> EcalClusterToolsT< noZS >::matrixDetId ( const CaloTopology *  topology, DetId  id, int  ixMin, int  ixMax, int  iyMin, int  iyMax, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

template<bool noZS>

float EcalClusterToolsT< noZS >::matrixEnergy ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, DetId  id, int  ixMin, int  ixMax, int  iyMin, int  iyMax  )

static

Definition at line 419 of file EcalClusterTools.h.

References relval_parameters_module::energy, cropTnPTrees::frac, CaloTopology::getSubdetectorTopology(), i, and j.

{
  //take into account fractions
    // fast version
    CaloNavigator<DetId> cursor = CaloNavigator<DetId>( id, topology->getSubdetectorTopology( id ) );
    float energy = 0;
    const std::vector< std::pair<DetId, float> >& v_id = cluster.hitsAndFractions();
    for ( int i = ixMin; i <= ixMax; ++i ) {
        for ( int j = iyMin; j <= iyMax; ++j ) {
      cursor.home();
      cursor.offsetBy( i, j );
      float frac=getFraction(v_id,*cursor);
      energy += recHitEnergy( *cursor, recHits )*frac;
        }
    }
    // slow elegant version
    //float energy = 0;
    //std::vector<DetId> v_id = matrixDetId( topology, id, ixMin, ixMax, iyMin, iyMax );
    //for ( std::vector<DetId>::const_iterator it = v_id.begin(); it != v_id.end(); ++it ) {
    //        energy += recHitEnergy( *it, recHits );
    //}
    return energy;
}

template<bool noZS>

float EcalClusterToolsT< noZS >::matrixEnergy ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, DetId  id, int  ixMin, int  ixMax, int  iyMin, int  iyMax, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 444 of file EcalClusterTools.h.

References relval_parameters_module::energy, cropTnPTrees::frac, CaloTopology::getSubdetectorTopology(), i, and j.

{
    // fast version
    CaloNavigator<DetId> cursor = CaloNavigator<DetId>( id, topology->getSubdetectorTopology( id ) );
    const std::vector< std::pair<DetId, float> >& v_id = cluster.hitsAndFractions();
    float energy = 0;
    for ( int i = ixMin; i <= ixMax; ++i ) {
        for ( int j = iyMin; j <= iyMax; ++j ) {
            cursor.home();
            cursor.offsetBy( i, j );
            float frac=getFraction(v_id,*cursor);
            energy += recHitEnergy( *cursor, recHits, flagsexcl, severitiesexcl, sevLv )*frac;
        }
    }
    return energy;
}

template<bool noZS>

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

staticprivate

Definition at line 1061 of file EcalClusterTools.h.

References relval_parameters_module::energy, and 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, 2, -2, 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 >::mean5x5PositionInLocalCrysCoord ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

staticprivate

Definition at line 1087 of file EcalClusterTools.h.

References relval_parameters_module::energy, and 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, 2, -2, 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,flagsexcl, severitiesexcl, sevLv) * 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 1119 of file EcalClusterTools.h.

References EcalBarrel, relval_parameters_module::energy, 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, 2, -2, 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>

std::pair< float, float > EcalClusterToolsT< noZS >::mean5x5PositionInXY ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

staticprivate

Definition at line 1147 of file EcalClusterTools.h.

References EcalBarrel, relval_parameters_module::energy, 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, 2, -2, 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,flagsexcl, severitiesexcl, sevLv) * (noZS ? 1.0 : 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 1015 of file EcalClusterTools.h.

References first, CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), 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, 2, -2, 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;
    GlobalPoint positionGP = geometry->getSubdetectorGeometry( *it )->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>

math::XYZVector EcalClusterToolsT< noZS >::meanClusterPosition ( const reco::BasicCluster &  cluster, const EcalRecHitCollection *  recHits, const CaloTopology *  topology, const CaloGeometry *  geometry, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

staticprivate

Definition at line 1035 of file EcalClusterTools.h.

References first, CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), 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, 2, -2, 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;
        GlobalPoint positionGP = geometry->getSubdetectorGeometry( *it )->getGeometry( *it )->getPosition();
        math::XYZVector position(positionGP.x(),positionGP.y(),positionGP.z());
        meanPosition = meanPosition + recHitEnergy( *it, recHits,flagsexcl, severitiesexcl, sevLv ) * position * hitAndFrac.second;
      }
      if(noZS) break; 
    }
    return meanPosition / e5x5( cluster, recHits, topology,flagsexcl, severitiesexcl, sevLv );
}

template<bool noZS>

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

static

Definition at line 347 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>

float EcalClusterToolsT< noZS >::recHitEnergy ( DetId  id, const EcalRecHitCollection *  recHits, const std::vector< int > &  flagsexcl, const std::vector< int > &  severitiesexcl, const EcalSeverityLevelAlgo *  sevLv  )

static

Definition at line 374 of file EcalClusterTools.h.

References edm::SortedCollection< T, SORT >::end(), spr::find(), edm::SortedCollection< T, SORT >::find(), and EcalSeverityLevelAlgo::severityLevel().

{
    if ( id == DetId(0) ) {
        return 0;
    } else {
        EcalRecHitCollection::const_iterator it = recHits->find( id );
        if ( it != recHits->end() ) {
      // avoid anomalous channels (recoFlag based)
      uint32_t rhFlag = (*it).recoFlag();
      std::vector<int>::const_iterator vit = std::find( flagsexcl.begin(), flagsexcl.end(), rhFlag );
      //if your flag was found to be one which is excluded, zero out
      //this energy.
      if ( vit != flagsexcl.end() ) return 0;
        
      int severityFlag =  sevLv->severityLevel( it->id(), *recHits);
      std::vector<int>::const_iterator sit = std::find(severitiesexcl.begin(), severitiesexcl.end(), severityFlag);
      //if you were flagged by some condition (kWeird etc.)
      //zero out this energy.
      if (sit!= severitiesexcl.end())
        return 0; 
      //If we make it here, you're a found, clean hit.
      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 2026 of file EcalClusterTools.h.

References edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), first, reco::CaloCluster::hitsAndFractions(), 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 2046 of file EcalClusterTools.h.

References funct::abs(), edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), first, EcalClusterToolsT< noZS >::getSeedPosition(), reco::CaloCluster::hitsAndFractions(), 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 2092 of file EcalClusterTools.h.

References cuy::denominator, CaloRecHit::detid(), CaloRecHit::energy(), EcalClusterToolsT< noZS >::getSeedPosition(), EcalClusterToolsT< noZS >::getSumEnergy(), i, create_public_lumi_plots::log, max(), groupFilesInBlocks::temp, and histoStyle::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(fabs(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(fabs(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 1697 of file EcalClusterTools.h.

References cuy::denominator, dPhi(), EcalBarrel, relval_parameters_module::energy, f, first, cropTnPTrees::frac, CaloTopology::getSubdetectorTopology(), reco::CaloCluster::hitsAndFractions(), i, create_public_lumi_plots::log, 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) {
            CaloNavigator<DetId> cursor = CaloNavigator<DetId>(v_id[i].first, topology->getSubdetectorTopology(v_id[i].first));
            float frac = getFraction(v_id,*cursor);
            float energy = recHitEnergy(*cursor, recHits)*frac;

            if (energy <= 0) continue;

            float dEta = getNrCrysDiffInEta(*cursor,seedId) - mean5x5PosInNrCrysFromSeed.first;
            float dPhi = 0;
            if(isBarrel)  dPhi = getNrCrysDiffInPhi(*cursor,seedId) - mean5x5PosInNrCrysFromSeed.second;
            else dPhi = getDPhiEndcap(*cursor,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>

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

static

Definition at line 1775 of file EcalClusterTools.h.

References cuy::denominator, dPhi(), EcalBarrel, relval_parameters_module::energy, f, first, cropTnPTrees::frac, CaloTopology::getSubdetectorTopology(), reco::CaloCluster::hitsAndFractions(), i, create_public_lumi_plots::log, 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,flagsexcl, severitiesexcl, sevLv);
        std::pair<float,float> mean5x5XYPos =  mean5x5PositionInXY(cluster,recHits,topology,flagsexcl, severitiesexcl, sevLv);
        // 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) {
            CaloNavigator<DetId> cursor = CaloNavigator<DetId>(v_id[i].first, topology->getSubdetectorTopology(v_id[i].first));
            float frac = getFraction(v_id,*cursor); 
            float energy = recHitEnergy(*cursor, recHits,flagsexcl, severitiesexcl, sevLv)*frac;

            if (energy <= 0) continue;

            float dEta = getNrCrysDiffInEta(*cursor,seedId) - mean5x5PosInNrCrysFromSeed.first;
            float dPhi = 0;
            if(isBarrel)  dPhi = getNrCrysDiffInPhi(*cursor,seedId) - mean5x5PosInNrCrysFromSeed.second;
            else dPhi = getDPhiEndcap(*cursor,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 1482 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 1488 of file EcalClusterTools.h.

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