hgcal::EGammaPCAHelper Class Reference

#include <EgammaPCAHelper.h>

Public Types
typedef ROOT::Math::Transform3DPJ::Point	Point
typedef ROOT::Math::Transform3DPJ	Transform3D

Public Member Functions
const math::XYZVector &	axis () const
const math::XYZPoint &	barycenter () const
void	clear ()
float	clusterDepthCompatibility (const LongDeps &, float &measuredDepth, float &expectedDepth, float &expectedSigma)
void	computePCA (float radius, bool withHalo=true)
void	computeShowerWidth (float radius, bool withHalo=true)
	EGammaPCAHelper ()
const TVectorD &	eigenValues () const
LongDeps	energyPerLayer (float radius, bool withHalo=true)
void	fillHitMap (const HGCRecHitCollection &HGCEERecHits, const HGCRecHitCollection &HGCFHRecHits, const HGCRecHitCollection &HGCBHRecHits)
	to compute from inside - once per event More...
std::map< DetId, const HGCRecHit * > *	getHitMap ()
void	pcaInitialComputation ()
const TPrincipal &	pcaResult ()
void	printHits (float radius) const
void	setdEdXWeights (const std::vector< double > &dEdX)
void	setHitMap (std::map< DetId, const HGCRecHit * > *hitMap)
	to set from outside - once per event More...
void	setRecHitTools (const hgcal::RecHitTools *recHitTools)
double	sigmaEE () const
double	sigmaPP () const
const TVectorD &	sigmas () const
double	sigmaUU () const
double	sigmaVV () const
void	storeRecHits (const reco::CaloCluster &theCluster)
void	storeRecHits (const reco::HGCalMultiCluster &cluster)
	~EGammaPCAHelper ()

Private Member Functions
bool	checkIteration () const
float	findZFirstLayer (const LongDeps &) const
void	storeRecHits (const std::vector< std::pair< DetId, float >> &hf)

Private Attributes
math::XYZVector	axis_
math::XYZPoint	barycenter_
bool	debug_
std::vector< double >	dEdXWeights_
std::map< DetId, const HGCRecHit * > *	hitMap_
int	hitMapOrigin_
std::vector< double >	invThicknessCorrection_
std::unique_ptr< TPrincipal >	pca_
int	pcaIteration_
bool	recHitsStored_
const hgcal::RecHitTools *	recHitTools_
ShowerDepth	showerDepth_
double	sige_
double	sigp_
double	sigu_
double	sigv_
const reco::CaloCluster *	theCluster_
std::vector< Spot >	theSpots_
Transform3D	trans_

Detailed Description

Definition at line 33 of file EgammaPCAHelper.h.

Member Typedef Documentation

typedef ROOT::Math::Transform3DPJ::Point hgcal::EGammaPCAHelper::Point

Definition at line 37 of file EgammaPCAHelper.h.

typedef ROOT::Math::Transform3DPJ hgcal::EGammaPCAHelper::Transform3D

Definition at line 36 of file EgammaPCAHelper.h.

Constructor & Destructor Documentation

EGammaPCAHelper::EGammaPCAHelper

(

)

Definition at line 17 of file EgammaPCAHelper.cc.

                                :
  // Thickness correction to dEdx weights
  // (100um, 200um, 300um silicon)
  // See RecoLocalCalo.HGCalRecProducers.HGCalRecHit_cfi
  invThicknessCorrection_({1. / 1.132, 1. / 1.092, 1. / 1.084}),
  pca_(new TPrincipal(3, "D")) {
    hitMapOrigin_ = 0;
    hitMap_ = new std::map<DetId, const HGCRecHit *>();
    debug_ = false;
}

EGammaPCAHelper::~EGammaPCAHelper

(

)

Definition at line 28 of file EgammaPCAHelper.cc.

References hitMap_, and hitMapOrigin_.

                                  {
    if (hitMapOrigin_ == 2) delete hitMap_;
}

Member Function Documentation

const math::XYZVector& hgcal::EGammaPCAHelper::axis ( ) const

inline

Definition at line 66 of file EgammaPCAHelper.h.

References axis_, and computeShowerWidth().

Referenced by HGCalEgammaIDHelper::axis().

{return axis_;}

const math::XYZPoint& hgcal::EGammaPCAHelper::barycenter ( ) const

inline

Definition at line 65 of file EgammaPCAHelper.h.

References barycenter_.

Referenced by HGCalEgammaIDHelper::barycenter().

{return barycenter_;}

bool EGammaPCAHelper::checkIteration ( ) const

private

Definition at line 235 of file EgammaPCAHelper.cc.

References gather_cfg::cout, debug_, and pcaIteration_.

Referenced by clusterDepthCompatibility(), energyPerLayer(), sigmaEE(), sigmaPP(), sigmas(), sigmaUU(), and sigmaVV().

                                           {
    if (pcaIteration_ == 0) {
        if(debug_)
            std::cout << " The PCA has not been run yet " << std::endl;
        return false;
    }   else if (pcaIteration_ == 1) {
        if (debug_)
            std::cout << " The PCA has been run only once - careful " << std::endl;
        return false;
    }   else if (pcaIteration_ == -1){
        if (debug_)
            std::cout << " Not enough layers to perform PCA " << std::endl;
        return false;
    }
    return true;
}

void EGammaPCAHelper::clear

(

void

)

Definition at line 252 of file EgammaPCAHelper.cc.

References pcaIteration_, sige_, sigp_, sigu_, sigv_, and theSpots_.

Referenced by HGCalEgammaIDHelper::computeHGCAL(), and sigmas().

                            {
    theSpots_.clear();
    pcaIteration_ = 0;
    sigu_ = 0.;
    sigv_ = 0.;
    sigp_ = 0.;
    sige_ = 0.;
}

float EGammaPCAHelper::clusterDepthCompatibility	(	const LongDeps &	ld,
		float &	measuredDepth,
		float &	expectedDepth,
		float &	expectedSigma
	)

Definition at line 321 of file EgammaPCAHelper.cc.

References funct::abs(), axis_, barycenter_, checkIteration(), dir, hgcal::LongDeps::energyEE(), findZFirstLayer(), hgcal::ShowerDepth::getClusterDepthCompatibility(), and showerDepth_.

Referenced by HGCalEgammaIDHelper::clusterDepthCompatibility(), and sigmas().

                                                                                                                                      {
    expectedDepth = -999.;
    expectedSigma = -999.;
    measuredDepth = -999.;
    if (!checkIteration()) return -999.;

    float z = findZFirstLayer(ld);
    math::XYZVector dir=axis_.unit();
    measuredDepth = std::abs((z-std::abs(barycenter_.z()))/dir.z());
    return showerDepth_.getClusterDepthCompatibility(measuredDepth,ld.energyEE(), expectedDepth,expectedSigma);
}

void EGammaPCAHelper::computePCA	(	float	radius,
		bool	withHalo = true
	)

Definition at line 135 of file EgammaPCAHelper.cc.

References axis_, barycenter_, gather_cfg::cout, debug_, mps_fire::i, hgcal::RecHitTools::lastLayerEE(), LayerTriplets::layers(), DTRecHitQuality_cfi::local, pca_, pcaIteration_, TCMET_cfi::radius, recHitTools_, theSpots_, and trans_.

Referenced by HGCalEgammaIDHelper::computeHGCAL(), and pcaInitialComputation().

                                                             {
    // very important - to reset
    pca_.reset(new TPrincipal(3, "D"));
    bool initialCalculation = radius < 0;
    if (debug_)
        std::cout << " Initial calculation " << initialCalculation << std::endl;
    if (initialCalculation && withHalo) {
        edm::LogWarning("EGammaPCAHelper") << "Warning - in the first iteration, the halo hits are excluded " << std::endl;
        withHalo=false;
    }

    float radius2 = radius*radius;
    if (! initialCalculation)     {
        math::XYZVector mainAxis(axis_);
        mainAxis.unit();
        math::XYZVector phiAxis(barycenter_.x(), barycenter_.y(), 0);
        math::XYZVector udir(mainAxis.Cross(phiAxis));
        udir = udir.unit();
        trans_ = Transform3D(Point(barycenter_), Point(barycenter_ + axis_), Point(barycenter_ + udir), Point(0, 0, 0),
        Point(0., 0., 1.), Point(1., 0., 0.));
    }

    std::set<int> layers;
    for (const auto& spot : theSpots_) {
        if (spot.layer() > recHitTools_->lastLayerEE()) continue;
        if (!withHalo && (! spot.isCore() ))
            continue;
        if (initialCalculation) {
            // initial calculation, take only core hits
            if ( ! spot.isCore() ) continue;
            layers.insert(spot.layer());
            for (int i = 0; i < spot.multiplicity(); ++i)
                pca_->AddRow(spot.row());
        }
        else {
            // use a cylinder, include all hits
            math::XYZPoint local = trans_(Point( spot.row()[0],spot.row()[1],spot.row()[2]));
            if (local.Perp2() > radius2) continue;
            layers.insert(spot.layer());
            for (int i = 0; i < spot.multiplicity(); ++i)
                pca_->AddRow(spot.row());
        }
    }
    if (debug_)
        std::cout << " Nlayers " << layers.size() << std::endl;
    if (layers.size() < 3) {
        pcaIteration_ = -1;
        return;
    }
    pca_->MakePrincipals();
    ++pcaIteration_;
    const TVectorD& means = *(pca_->GetMeanValues());
    const TMatrixD& eigens = *(pca_->GetEigenVectors());

    barycenter_ = math::XYZPoint(means[0], means[1], means[2]);
    axis_ = math::XYZVector(eigens(0, 0), eigens(1, 0), eigens(2, 0));
    if (axis_.z() * barycenter_.z() < 0.0) {
        axis_ = -1. * axis_;
    }
}

void EGammaPCAHelper::computeShowerWidth	(	float	radius,
		bool	withHalo = true
	)

Definition at line 196 of file EgammaPCAHelper.cc.

References hiPixelPairStep_cff::deltaPhi, reco::CaloCluster::eta(), DTRecHitQuality_cfi::local, reco::CaloCluster::phi(), TCMET_cfi::radius, sige_, sigp_, sigu_, sigv_, mathSSE::sqrt(), theCluster_, theSpots_, and trans_.

Referenced by axis(), and HGCalEgammaIDHelper::computeHGCAL().

                                                                    {
    sigu_ = 0.;
    sigv_ = 0.;
    sigp_ = 0.;
    sige_ = 0.;
    double cyl_ene = 0.;

    float radius2 = radius * radius;
    for (const auto& spot : theSpots_) {
        Point globalPoint(spot.row()[0],spot.row()[1],spot.row()[2]);
        math::XYZPoint local = trans_(globalPoint);
        if (local.Perp2() > radius2) continue;

        // Select halo hits or not
        if (withHalo && spot.fraction() < 0) continue;
        if (!withHalo && !(spot.isCore())) continue;

        sige_ += (globalPoint.eta() - theCluster_->eta()) * (globalPoint.eta() - theCluster_->eta()) * spot.energy();
        sigp_ += deltaPhi(globalPoint.phi(), theCluster_->phi()) * deltaPhi(globalPoint.phi(), theCluster_->phi()) *
              spot.energy();

        sigu_ += local.x() * local.x() * spot.energy();
        sigv_ += local.y() * local.y() * spot.energy();
        cyl_ene += spot.energy();
    }

  if (cyl_ene > 0.) {
    const double inv_cyl_ene = 1. / cyl_ene;
    sigu_ = sigu_ * inv_cyl_ene;
    sigv_ = sigv_ * inv_cyl_ene;
    sigp_ = sigp_ * inv_cyl_ene;
    sige_ = sige_ * inv_cyl_ene;
  }
  sigu_ = std::sqrt(sigu_);
  sigv_ = std::sqrt(sigv_);
  sigp_ = std::sqrt(sigp_);
  sige_ = std::sqrt(sige_);
}

const TVectorD& hgcal::EGammaPCAHelper::eigenValues ( ) const

inline

Definition at line 75 of file EgammaPCAHelper.h.

References pca_.

Referenced by HGCalEgammaIDHelper::eigenValues().

{return *pca_->GetEigenValues();}

LongDeps EGammaPCAHelper::energyPerLayer	(	float	radius,
		bool	withHalo = true
	)

Definition at line 261 of file EgammaPCAHelper.cc.

References axis_, barycenter_, checkIteration(), debug_, f, HGCEE, HGCHEB, HGCHEF, LayerTriplets::layers(), DTRecHitQuality_cfi::local, HGCalImagingAlgo::maxlayer, TCMET_cfi::radius, theSpots_, and trans_.

Referenced by HGCalEgammaIDHelper::energyPerLayer(), and sigmas().

                                                                     {
    if (debug_) checkIteration();
    std::set<int> layers;
    float radius2 = radius*radius;
    std::vector<float> energyPerLayer(HGCalImagingAlgo::maxlayer+1, 0.f);
    math::XYZVector mainAxis(axis_);
    mainAxis.unit();
    math::XYZVector phiAxis(barycenter_.x(), barycenter_.y(), 0);
    math::XYZVector udir(mainAxis.Cross(phiAxis));
    udir = udir.unit();
    trans_ = Transform3D(Point(barycenter_), Point(barycenter_ + axis_), Point(barycenter_ + udir), Point(0, 0, 0),
    Point(0., 0., 1.), Point(1., 0., 0.));
    float energyEE = 0.;
    float energyFH = 0.;
    float energyBH = 0.;

    for (const auto& spot : theSpots_) {
        if (!withHalo && ! spot.isCore())
            continue;
        math::XYZPoint local = trans_(Point( spot.row()[0],spot.row()[1],spot.row()[2]));
        if (local.Perp2() > radius2) continue;
        energyPerLayer[spot.layer()] += spot.energy();
        layers.insert(spot.layer());
        if (spot.subdet() == HGCEE) { energyEE += spot.energy();}
        else if (spot.subdet() == HGCHEF) { energyFH += spot.energy();}
        else if (spot.subdet() == HGCHEB) { energyBH += spot.energy();}

    }
    return LongDeps(radius,energyPerLayer,energyEE,energyFH,energyBH,layers);
}

void EGammaPCAHelper::fillHitMap	(	const HGCRecHitCollection &	HGCEERecHits,
		const HGCRecHitCollection &	HGCFHRecHits,
		const HGCRecHitCollection &	HGCBHRecHits
	)

to compute from inside - once per event

Definition at line 42 of file EgammaPCAHelper.cc.

References hitMap_, hitMapOrigin_, and pcaIteration_.

Referenced by HGCalEgammaIDHelper::eventInit().

                                                                        {
    hitMap_->clear();
    for (const auto& hit : rechitsEE) {
        hitMap_->emplace_hint(hitMap_->end(), hit.detid(), &hit);
    }

    for (const auto& hit : rechitsFH) {
        hitMap_->emplace_hint(hitMap_->end(), hit.detid(), &hit);
    }

    for (const auto& hit : rechitsBH) {
        hitMap_->emplace_hint(hitMap_->end(), hit.detid(), &hit);
    }

    pcaIteration_ = 0;
    hitMapOrigin_ = 2;
}

float EGammaPCAHelper::findZFirstLayer ( const LongDeps &  ld ) const

private

Definition at line 305 of file EgammaPCAHelper.cc.

References hgcal::LongDeps::energyPerLayer(), hgcal::RecHitTools::getPosition(), HcalEndcap, HGCEE, HGCHEF, hcalTTPDigis_cfi::id, hgcal::RecHitTools::lastLayerEE(), hgcal::RecHitTools::lastLayerFH(), HGCalImagingAlgo::maxlayer, recHitTools_, and PV3DBase< T, PVType, FrameType >::z().

Referenced by clusterDepthCompatibility(), and sigmas().

                                                                {
    unsigned int firstLayer = 0;
    for(unsigned il=1;il<=HGCalImagingAlgo::maxlayer;++il) {
        if (ld.energyPerLayer()[il] > 0.) {
            firstLayer = il;
            break;
        }
    }
    // Make dummy DetId to get abs(z) for layer
    DetId id;
    if (firstLayer <= recHitTools_->lastLayerEE()) id = HGCalDetId(ForwardSubdetector::HGCEE, 1, firstLayer, 1, 50, 1);
    else if (firstLayer <= recHitTools_->lastLayerFH()) id = HGCalDetId(ForwardSubdetector::HGCHEF, 1, firstLayer - recHitTools_->lastLayerEE(), 1, 50, 1);
    else  id = HcalDetId(HcalSubdetector::HcalEndcap, 50, 100, firstLayer - recHitTools_->lastLayerFH());
    return recHitTools_->getPosition(id).z();
}

std::map<DetId,const HGCRecHit *>* hgcal::EGammaPCAHelper::getHitMap ( )

inline

Definition at line 54 of file EgammaPCAHelper.h.

References hitMap_, and setRecHitTools().

{return hitMap_;}

void hgcal::EGammaPCAHelper::pcaInitialComputation ( )

inline

Definition at line 60 of file EgammaPCAHelper.h.

References computePCA(), and TCMET_cfi::radius.

Referenced by HGCalEgammaIDHelper::computeHGCAL().

                                   {
          computePCA(-1.,false);
      }

const TPrincipal& hgcal::EGammaPCAHelper::pcaResult

(

)

void EGammaPCAHelper::printHits

(

float

radius

)

const

Definition at line 292 of file EgammaPCAHelper.cc.

References gather_cfg::cout, mps_fire::i, DTRecHitQuality_cfi::local, TCMET_cfi::radius, hgcal::Spot::row(), mathSSE::sqrt(), theSpots_, and trans_.

Referenced by ntuplePrintersDiff.TrackingParticlePrinter::__call__(), ntuplePrintersDiff.SeedPrinter::diff(), ntuplePrintersDiff.TrackPrinter::diff(), ntuplePrintersDiff.TrackingParticlePrinter::diff(), HGCalEgammaIDHelper::printHits(), ntuplePrintersDiff.SeedPrinter::printSeed(), ntuplePrintersDiff.TrackPrinter::printTrack(), and sigmas().

                                                  {
    unsigned nSpots = theSpots_.size();
    float radius2=radius*radius;
    for ( unsigned i =0; i< nSpots ; ++i) {
        Spot spot(theSpots_[i]);
        math::XYZPoint local = trans_(Point( spot.row()[0],spot.row()[1],spot.row()[2]));
        if (local.Perp2() < radius2 ) {
            std::cout << i << "  " << theSpots_[i].detId().rawId() << " " << theSpots_[i].layer() << " " << theSpots_[i].energy() << " " <<theSpots_[i].isCore() ;
            std::cout << " " << std::sqrt(local.Perp2()) << std::endl;
        }
    }
}

void hgcal::EGammaPCAHelper::setdEdXWeights ( const std::vector< double > &  dEdX )

inline

Definition at line 58 of file EgammaPCAHelper.h.

References dEdXWeights_.

Referenced by HGCalEgammaIDHelper::HGCalEgammaIDHelper().

{ dEdXWeights_ = dEdX;}

void EGammaPCAHelper::setHitMap

(

std::map< DetId, const HGCRecHit * > *

hitMap

)

to set from outside - once per event

Definition at line 32 of file EgammaPCAHelper.cc.

References hitMap_, hitMapOrigin_, and pcaIteration_.

                                                                         {
    hitMapOrigin_ = 1;
    hitMap_ = hitMap ;
    pcaIteration_ = 0;
}

void EGammaPCAHelper::setRecHitTools

(

const hgcal::RecHitTools *

recHitTools

)

Definition at line 38 of file EgammaPCAHelper.cc.

References recHitTools_.

Referenced by HGCalEgammaIDHelper::eventInit(), and getHitMap().

                                                                          {
    recHitTools_ = recHitTools;
}

double hgcal::EGammaPCAHelper::sigmaEE ( ) const

inline

Definition at line 72 of file EgammaPCAHelper.h.

References checkIteration(), and sige_.

Referenced by HGCalEgammaIDHelper::sigmaEE().

{ return checkIteration()? sige_ : -1. ;}

double hgcal::EGammaPCAHelper::sigmaPP ( ) const

inline

Definition at line 73 of file EgammaPCAHelper.h.

References checkIteration(), and sigp_.

Referenced by HGCalEgammaIDHelper::sigmaPP().

{ return checkIteration()? sigp_ : -1. ;}

const TVectorD& hgcal::EGammaPCAHelper::sigmas ( ) const

inline

Definition at line 76 of file EgammaPCAHelper.h.

References checkIteration(), clear(), clusterDepthCompatibility(), energyPerLayer(), findZFirstLayer(), photonIsolationHIProducer_cfi::hf, pca_, printHits(), and storeRecHits().

Referenced by HGCalEgammaIDHelper::sigmas().

{return *pca_->GetSigmas();}

double hgcal::EGammaPCAHelper::sigmaUU ( ) const

inline

Definition at line 70 of file EgammaPCAHelper.h.

References checkIteration(), and sigu_.

Referenced by HGCalEgammaIDHelper::sigmaUU().

{ return checkIteration()? sigu_ : -1. ;}

double hgcal::EGammaPCAHelper::sigmaVV ( ) const

inline

Definition at line 71 of file EgammaPCAHelper.h.

References checkIteration(), and sigv_.

Referenced by HGCalEgammaIDHelper::sigmaVV().

{ return checkIteration()? sigv_ : -1. ;}

void EGammaPCAHelper::storeRecHits

(

const reco::CaloCluster &

theCluster

)

Definition at line 73 of file EgammaPCAHelper.cc.

References reco::CaloCluster::hitsAndFractions(), and theCluster_.

Referenced by HGCalEgammaIDHelper::computeHGCAL(), sigmas(), and storeRecHits().

                                                                  {
    theCluster_ = &cluster;
    storeRecHits(cluster.hitsAndFractions());
}

void EGammaPCAHelper::storeRecHits

(

const reco::HGCalMultiCluster &

cluster

)

Definition at line 62 of file EgammaPCAHelper.cc.

References reco::HGCalMultiCluster::begin(), reco::HGCalMultiCluster::end(), photonIsolationHIProducer_cfi::hf, mps_fire::result, storeRecHits(), and theCluster_.

                                                                       {
    theCluster_ = &cluster;
    std::vector<std::pair<DetId, float>> result;
    for (reco::HGCalMultiCluster::component_iterator it = cluster.begin(); it != cluster.end();
    it++) {
        const std::vector<std::pair<DetId, float>> &hf = (*it)->hitsAndFractions();
        result.insert(result.end(),hf.begin(),hf.end());
    }
    storeRecHits(result);
}

void EGammaPCAHelper::storeRecHits ( const std::vector< std::pair< DetId, float >> &  hf )

private

Definition at line 78 of file EgammaPCAHelper.cc.

References gather_cfg::cout, debug_, dEdXWeights_, DetId::det(), plotBeamSpotDB::first, DetId::Forward, dedxEstimators_cff::fraction, hgcal::RecHitTools::getLayerWithOffset(), hgcal::RecHitTools::getPosition(), hgcal::RecHitTools::getSiThickness(), photonIsolationHIProducer_cfi::hf, hitMap_, invThicknessCorrection_, pcaIteration_, DetId::rawId(), recHitTools_, sige_, sigp_, sigu_, sigv_, theSpots_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                             {
    std::vector<double> pcavars;
    pcavars.resize(3,0.);
    theSpots_.clear();
    pcaIteration_ = 0;

    sigu_ = 0.;
    sigv_ = 0.;
    sigp_ = 0.;
    sige_ = 0.;

    unsigned hfsize = hf.size();
    if (debug_)
        std::cout << "The seed cluster constains " << hfsize << " hits " << std::endl;

    if (hfsize == 0) return;


    for (unsigned int j = 0; j < hfsize; j++) {
        unsigned int layer = recHitTools_->getLayerWithOffset(hf[j].first);

        const DetId rh_detid = hf[j].first;
        std::map<DetId,const HGCRecHit *>::const_iterator itcheck= hitMap_->find(rh_detid);
        if (itcheck == hitMap_->end()) {
            edm::LogWarning("EgammaPCAHelper") << " Big problem, unable to find a hit " << rh_detid.rawId() << " " << rh_detid.det() << " " << HGCalDetId(rh_detid) << std::endl;
            continue;
        }
        if (debug_) {
            std::cout << "DetId " << rh_detid.rawId() << " " << layer << " " <<  itcheck->second->energy() <<std::endl;
            std::cout << " Hit " << itcheck->second << " " << itcheck->second->energy() << std::endl;
        }
        float fraction = hf[j].second;

        double thickness = (DetId::Forward == DetId(rh_detid).det()) ? recHitTools_->getSiThickness(rh_detid) : -1;
        double mip = dEdXWeights_[layer] * 0.001;  // convert in GeV
        if (thickness > 99. && thickness < 101)
            mip *= invThicknessCorrection_[0];
        else if (thickness > 199 && thickness < 201)
            mip *= invThicknessCorrection_[1];
        else if (thickness > 299 && thickness < 301)
            mip *= invThicknessCorrection_[2];

        pcavars[0] = recHitTools_->getPosition(rh_detid).x();
        pcavars[1] = recHitTools_->getPosition(rh_detid).y();
        pcavars[2] = recHitTools_->getPosition(rh_detid).z();
        if (pcavars[2] == 0.)
            edm::LogWarning("EgammaPCAHelper") << " Problem, hit with z =0 ";
        else  {
            Spot mySpot(rh_detid,itcheck->second->energy(),pcavars,layer,fraction,mip);
            theSpots_.push_back(mySpot);
        }
    }
    if (debug_) {
        std::cout << " Stored " << theSpots_.size() << " hits " << std::endl;
    }
}

Member Data Documentation

math::XYZVector hgcal::EGammaPCAHelper::axis_

private

Definition at line 104 of file EgammaPCAHelper.h.

Referenced by axis(), clusterDepthCompatibility(), computePCA(), and energyPerLayer().

math::XYZPoint hgcal::EGammaPCAHelper::barycenter_

private

Definition at line 103 of file EgammaPCAHelper.h.

Referenced by barycenter(), clusterDepthCompatibility(), computePCA(), and energyPerLayer().

bool hgcal::EGammaPCAHelper::debug_

private

Definition at line 90 of file EgammaPCAHelper.h.

Referenced by checkIteration(), computePCA(), energyPerLayer(), and storeRecHits().

std::vector<double> hgcal::EGammaPCAHelper::dEdXWeights_

private

Definition at line 93 of file EgammaPCAHelper.h.

Referenced by setdEdXWeights(), and storeRecHits().

std::map<DetId, const HGCRecHit *>* hgcal::EGammaPCAHelper::hitMap_

private

Definition at line 98 of file EgammaPCAHelper.h.

Referenced by fillHitMap(), getHitMap(), setHitMap(), storeRecHits(), and ~EGammaPCAHelper().

int hgcal::EGammaPCAHelper::hitMapOrigin_

private

Definition at line 96 of file EgammaPCAHelper.h.

Referenced by fillHitMap(), setHitMap(), and ~EGammaPCAHelper().

std::vector<double> hgcal::EGammaPCAHelper::invThicknessCorrection_

private

Definition at line 94 of file EgammaPCAHelper.h.

Referenced by storeRecHits().

std::unique_ptr<TPrincipal> hgcal::EGammaPCAHelper::pca_

private

Definition at line 110 of file EgammaPCAHelper.h.

Referenced by computePCA(), eigenValues(), and sigmas().

int hgcal::EGammaPCAHelper::pcaIteration_

private

Definition at line 100 of file EgammaPCAHelper.h.

Referenced by checkIteration(), clear(), computePCA(), fillHitMap(), setHitMap(), and storeRecHits().

bool hgcal::EGammaPCAHelper::recHitsStored_

private

Definition at line 89 of file EgammaPCAHelper.h.

const hgcal::RecHitTools* hgcal::EGammaPCAHelper::recHitTools_

private

Definition at line 111 of file EgammaPCAHelper.h.

Referenced by computePCA(), findZFirstLayer(), setRecHitTools(), and storeRecHits().

ShowerDepth hgcal::EGammaPCAHelper::showerDepth_

private

Definition at line 112 of file EgammaPCAHelper.h.

Referenced by clusterDepthCompatibility().

double hgcal::EGammaPCAHelper::sige_

private

Definition at line 107 of file EgammaPCAHelper.h.

Referenced by clear(), computeShowerWidth(), sigmaEE(), and storeRecHits().

double hgcal::EGammaPCAHelper::sigp_

private

Definition at line 107 of file EgammaPCAHelper.h.

Referenced by clear(), computeShowerWidth(), sigmaPP(), and storeRecHits().

double hgcal::EGammaPCAHelper::sigu_

private

Definition at line 107 of file EgammaPCAHelper.h.

Referenced by clear(), computeShowerWidth(), sigmaUU(), and storeRecHits().

double hgcal::EGammaPCAHelper::sigv_

private

Definition at line 107 of file EgammaPCAHelper.h.

Referenced by clear(), computeShowerWidth(), sigmaVV(), and storeRecHits().

const reco::CaloCluster* hgcal::EGammaPCAHelper::theCluster_

private

Definition at line 97 of file EgammaPCAHelper.h.

Referenced by computeShowerWidth(), and storeRecHits().

std::vector<Spot> hgcal::EGammaPCAHelper::theSpots_

private

Definition at line 99 of file EgammaPCAHelper.h.

Referenced by clear(), computePCA(), computeShowerWidth(), energyPerLayer(), printHits(), and storeRecHits().

Transform3D hgcal::EGammaPCAHelper::trans_

private

Definition at line 106 of file EgammaPCAHelper.h.

Referenced by computePCA(), computeShowerWidth(), energyPerLayer(), and printHits().