HGCalShowerShapeHelper::ShowerShapeCalc Class Reference

#include <HGCalShowerShapeHelper.h>

Public Member Functions
double	getCellSize (DetId detId) const
std::vector< double >	getEnergyHighestHits (unsigned int nrHits, bool useFractions=true) const
ShowerWidths	getPCAWidths (double cylinderR, bool useFractions=false) const
double	getRvar (double cylinderR, bool useFractions=true, bool useCellSize=true) const
	ShowerShapeCalc (std::shared_ptr< const hgcal::RecHitTools > recHitTools, std::shared_ptr< const std::unordered_map< uint32_t, const reco::PFRecHit * > > pfRecHitPtrMap, const std::vector< std::pair< DetId, float > > &hitsAndFracs, const double rawEnergy, const double minHitE=0, const double minHitET=0, const int minLayer=1, const int maxLayer=-1, DetId::Detector subDet=DetId::HGCalEE)

Private Member Functions
void	setFilteredHitsAndFractions (const std::vector< std::pair< DetId, float > > &hitsAndFracs)
void	setLayerWiseInfo ()

Private Attributes
ROOT::Math::XYZVector	centroid_
std::vector< double >	hitEnergies_
std::vector< double >	hitEnergiesWithFracs_
std::vector< std::pair< DetId, float > >	hitsAndFracs_
std::vector< ROOT::Math::XYZVector >	layerCentroids_
std::vector< double >	layerEnergies_
int	maxLayer_
double	minHitE_
double	minHitET2_
double	minHitET_
int	minLayer_
int	nLayer_
std::shared_ptr< const std::unordered_map< uint32_t, const reco::PFRecHit * > >	pfRecHitPtrMap_
double	rawEnergy_
std::shared_ptr< const hgcal::RecHitTools >	recHitTools_
DetId::Detector	subDet_

Detailed Description

Definition at line 88 of file HGCalShowerShapeHelper.h.

Constructor & Destructor Documentation

ShowerShapeCalc()

HGCalShowerShapeHelper::ShowerShapeCalc::ShowerShapeCalc	(	std::shared_ptr< const hgcal::RecHitTools >	recHitTools,
		std::shared_ptr< const std::unordered_map< uint32_t, const reco::PFRecHit * > >	pfRecHitPtrMap,
		const std::vector< std::pair< DetId, float > > &	hitsAndFracs,
		const double	rawEnergy,
		const double	minHitE = 0,
		const double	minHitET = 0,
		const int	minLayer = 1,
		const int	maxLayer = -1,
		DetId::Detector	subDet = DetId::HGCalEE
	)

Definition at line 6 of file HGCalShowerShapeHelper.cc.

    : recHitTools_(recHitTools),
      pfRecHitPtrMap_(pfRecHitPtrMap),
      rawEnergy_(rawEnergy),
      minHitE_(minHitE),
      minHitET_(minHitET),
      minHitET2_(minHitET * minHitET),
      minLayer_(minLayer),
      maxLayer_(maxLayer <= 0 ? recHitTools_->lastLayerEE() : maxLayer),
      nLayer_(maxLayer_ - minLayer_ + 1),
      subDet_(subDet) {
  assert(nLayer_ > 0);
  setFilteredHitsAndFractions(hitsAndFracs);
  setLayerWiseInfo();
}

References cms::cuda::assert(), nLayer_, setFilteredHitsAndFractions(), and setLayerWiseInfo().

Member Function Documentation

getCellSize()

double HGCalShowerShapeHelper::ShowerShapeCalc::getCellSize

(

DetId

detId

)

const

Definition at line 31 of file HGCalShowerShapeHelper.cc.

                                                                           {
  return recHitTools_->getSiThickIndex(detId) == 0 ? kHDWaferCellSize_ : kLDWaferCellSize_;
}

References HGCalShowerShapeHelper::kHDWaferCellSize_, HGCalShowerShapeHelper::kLDWaferCellSize_, and HGCalShowerShapeHelper::recHitTools_.

getEnergyHighestHits()

std::vector< double > HGCalShowerShapeHelper::ShowerShapeCalc::getEnergyHighestHits	(	unsigned int	nrHits,
		bool	useFractions = true
	)		const

Definition at line 192 of file HGCalShowerShapeHelper.cc.

                                                                                                           {
  std::vector<double> sortedEnergies(nrHits, 0.);
  const auto &hits = useFractions ? hitEnergiesWithFracs_ : hitEnergies_;
  std::partial_sort_copy(
      hits.begin(), hits.end(), sortedEnergies.begin(), sortedEnergies.end(), std::greater<double>());
  return sortedEnergies;
}

References hfClusterShapes_cfi::hits.

getPCAWidths()

HGCalShowerShapeHelper::ShowerWidths HGCalShowerShapeHelper::ShowerShapeCalc::getPCAWidths	(	double	cylinderR,
		bool	useFractions = false
	)		const

Definition at line 86 of file HGCalShowerShapeHelper.cc.

                                                                                                                    {
  if (hitsAndFracs_.empty()) {
    return ShowerWidths();
  }
 
  double cylinderR2 = cylinderR * cylinderR;
 
  TMatrixD covMat(3, 3);
 
  double dxdx = 0.0;
  double dydy = 0.0;
  double dzdz = 0.0;
 
  double dxdy = 0.0;
  double dydz = 0.0;
  double dzdx = 0.0;
 
  double totalW = 0.0;
 
  auto hitEnergyIter = useFractions ? hitEnergiesWithFracs_.begin() : hitEnergies_.begin();
 
  int nHit = 0;
  hitEnergyIter--;
 
  for (const auto &hnf : hitsAndFracs_) {
    hitEnergyIter++;
 
    DetId hitId = hnf.first;
 
    const auto &hitPos = recHitTools_->getPosition(hitId);
    ROOT::Math::XYZVector hitXYZ(hitPos.x(), hitPos.y(), hitPos.z());
 
    int hitLayer = recHitTools_->getLayer(hitId) - 1;
 
    ROOT::Math::XYZVector radXYZ = hitXYZ - layerCentroids_[hitLayer];
 
    double r2 = radXYZ.x() * radXYZ.x() + radXYZ.y() * radXYZ.y();
 
    if (r2 > cylinderR2) {
      continue;
    }
 
    ROOT::Math::XYZVector dXYZ = hitXYZ - centroid_;
 
    double weight = *hitEnergyIter;
    totalW += weight;
 
    dxdx += weight * dXYZ.x() * dXYZ.x();
    dydy += weight * dXYZ.y() * dXYZ.y();
    dzdz += weight * dXYZ.z() * dXYZ.z();
 
    dxdy += weight * dXYZ.x() * dXYZ.y();
    dydz += weight * dXYZ.y() * dXYZ.z();
    dzdx += weight * dXYZ.z() * dXYZ.x();
 
    nHit++;
  }
 
  if (!totalW || nHit < 2) {
    return ShowerWidths();
  }
 
  dxdx /= totalW;
  dydy /= totalW;
  dzdz /= totalW;
 
  dxdy /= totalW;
  dydz /= totalW;
  dzdx /= totalW;
 
  covMat(0, 0) = dxdx;
  covMat(1, 1) = dydy;
  covMat(2, 2) = dzdz;
 
  covMat(0, 1) = covMat(1, 0) = dxdy;
  covMat(0, 2) = covMat(2, 0) = dzdx;
  covMat(1, 2) = covMat(2, 1) = dydz;
 
  if (!covMat.Sum()) {
    return ShowerWidths();
  }
 
  // Get eigen values and vectors
  TVectorD eigVals(3);
  TMatrixD eigVecMat(3, 3);
 
  eigVecMat = covMat.EigenVectors(eigVals);
 
  ShowerWidths returnWidths;
 
  returnWidths.sigma2xx = dxdx;
  returnWidths.sigma2yy = dydy;
  returnWidths.sigma2zz = dzdz;
 
  returnWidths.sigma2xy = dxdy;
  returnWidths.sigma2yz = dydz;
  returnWidths.sigma2zx = dzdx;
 
  returnWidths.sigma2uu = eigVals(1);
  returnWidths.sigma2vv = eigVals(2);
  returnWidths.sigma2ww = eigVals(0);
 
  return returnWidths;
}

References BeamSpotPI::dydz, diffTwoXMLs::r2, HGCalShowerShapeHelper::recHitTools_, HGCalShowerShapeHelper::ShowerWidths::sigma2uu, HGCalShowerShapeHelper::ShowerWidths::sigma2vv, HGCalShowerShapeHelper::ShowerWidths::sigma2ww, HGCalShowerShapeHelper::ShowerWidths::sigma2xx, HGCalShowerShapeHelper::ShowerWidths::sigma2xy, HGCalShowerShapeHelper::ShowerWidths::sigma2yy, HGCalShowerShapeHelper::ShowerWidths::sigma2yz, HGCalShowerShapeHelper::ShowerWidths::sigma2zx, HGCalShowerShapeHelper::ShowerWidths::sigma2zz, and mps_merge::weight.

Referenced by SCEnergyCorrectorSemiParm::getRegDataHGCALV1().

getRvar()

double HGCalShowerShapeHelper::ShowerShapeCalc::getRvar	(	double	cylinderR,
		bool	useFractions = true,
		bool	useCellSize = true
	)		const

Definition at line 35 of file HGCalShowerShapeHelper.cc.

                                                                                                                 {
  if (hitsAndFracs_.empty()) {
    return 0.0;
  }
 
  if (rawEnergy_ <= 0.0) {
    edm::LogWarning("HGCalShowerShapeHelper")
        << "Encountered negative or zero energy for HGCal R-variable denominator: " << rawEnergy_ << std::endl;
  }
 
  double cylinderR2 = cylinderR * cylinderR;
 
  double rVar = 0.0;
 
  auto hitEnergyIter = useFractions ? hitEnergiesWithFracs_.begin() : hitEnergies_.begin();
 
  hitEnergyIter--;
 
  for (const auto &hnf : hitsAndFracs_) {
    hitEnergyIter++;
 
    DetId hitId = hnf.first;
 
    int hitLayer = recHitTools_->getLayer(hitId) - 1;
 
    const auto &hitPos = recHitTools_->getPosition(hitId);
    ROOT::Math::XYZVector hitXYZ(hitPos.x(), hitPos.y(), hitPos.z());
 
    auto distXYZ = hitXYZ - layerCentroids_[hitLayer];
 
    double r2 = distXYZ.x() * distXYZ.x() + distXYZ.y() * distXYZ.y();
 
    // Including the cell size seems to make the variable less sensitive to the HD/LD transition region
    if (useCellSize) {
      if (std::sqrt(r2) > cylinderR + getCellSize(hitId)) {
        continue;
      }
    }
 
    else if (r2 > cylinderR2) {
      continue;
    }
 
    rVar += *hitEnergyIter;
  }
 
  rVar /= rawEnergy_;
 
  return rVar;
}

References diffTwoXMLs::r2, HGCalShowerShapeHelper::recHitTools_, and mathSSE::sqrt().

setFilteredHitsAndFractions()

void HGCalShowerShapeHelper::ShowerShapeCalc::setFilteredHitsAndFractions ( const std::vector< std::pair< DetId, float > > &  hitsAndFracs )

private

Definition at line 201 of file HGCalShowerShapeHelper.cc.

                                                          {
  hitsAndFracs_.clear();
  hitEnergies_.clear();
  hitEnergiesWithFracs_.clear();
 
  for (const auto &hnf : hitsAndFracs) {
    DetId hitId = hnf.first;
    float hitEfrac = hnf.second;
 
    int hitLayer = recHitTools_->getLayer(hitId);
 
    if (hitLayer > nLayer_) {
      continue;
    }
 
    if (hitId.det() != subDet_) {
      continue;
    }
    auto hitIt = pfRecHitPtrMap_->find(hitId.rawId());
    if (hitIt == pfRecHitPtrMap_->end()) {
      continue;
    }
 
    const reco::PFRecHit &recHit = *hitIt->second;
 
    if (recHit.energy() < minHitE_) {
      continue;
    }
 
    if (recHit.pt2() < minHitET2_) {
      continue;
    }
 
    // Fill the vectors
    hitsAndFracs_.push_back(hnf);
    hitEnergies_.push_back(recHit.energy());
    hitEnergiesWithFracs_.push_back(recHit.energy() * hitEfrac);
  }
}

References DetId::det(), HGCalShowerShapeHelper::pfRecHitPtrMap_, DetId::rawId(), rpcPointValidation_cfi::recHit, and HGCalShowerShapeHelper::recHitTools_.

Referenced by ShowerShapeCalc().

setLayerWiseInfo()

void HGCalShowerShapeHelper::ShowerShapeCalc::setLayerWiseInfo ( )

private

Definition at line 242 of file HGCalShowerShapeHelper.cc.

                                                             {
  layerEnergies_.clear();
  layerEnergies_.resize(nLayer_);
 
  layerCentroids_.clear();
  layerCentroids_.resize(nLayer_);
 
  centroid_.SetXYZ(0, 0, 0);
 
  int iHit = -1;
  double totalW = 0.0;
 
  // Compute the centroid per layer
  for (const auto &hnf : hitsAndFracs_) {
    iHit++;
 
    DetId hitId = hnf.first;
 
    double weight = hitEnergies_[iHit];
    totalW += weight;
 
    const auto &hitPos = recHitTools_->getPosition(hitId);
    ROOT::Math::XYZVector hitXYZ(hitPos.x(), hitPos.y(), hitPos.z());
 
    centroid_ += weight * hitXYZ;
 
    int hitLayer = recHitTools_->getLayer(hitId) - 1;
 
    layerEnergies_[hitLayer] += weight;
    layerCentroids_[hitLayer] += weight * hitXYZ;
  }
 
  int iLayer = -1;
 
  for (auto &centroid : layerCentroids_) {
    iLayer++;
 
    if (layerEnergies_[iLayer]) {
      centroid /= layerEnergies_[iLayer];
    }
  }
 
  if (totalW) {
    centroid_ /= totalW;
  }
}

References HGCalShowerShapeHelper::recHitTools_, and mps_merge::weight.

Referenced by ShowerShapeCalc().

Member Data Documentation

centroid_

ROOT::Math::XYZVector HGCalShowerShapeHelper::ShowerShapeCalc::centroid_

private

Definition at line 130 of file HGCalShowerShapeHelper.h.

hitEnergies_

std::vector<double> HGCalShowerShapeHelper::ShowerShapeCalc::hitEnergies_

private

Definition at line 127 of file HGCalShowerShapeHelper.h.

hitEnergiesWithFracs_

std::vector<double> HGCalShowerShapeHelper::ShowerShapeCalc::hitEnergiesWithFracs_

private

Definition at line 128 of file HGCalShowerShapeHelper.h.

hitsAndFracs_

std::vector<std::pair<DetId, float> > HGCalShowerShapeHelper::ShowerShapeCalc::hitsAndFracs_

private

Definition at line 126 of file HGCalShowerShapeHelper.h.

layerCentroids_

std::vector<ROOT::Math::XYZVector> HGCalShowerShapeHelper::ShowerShapeCalc::layerCentroids_

private

Definition at line 132 of file HGCalShowerShapeHelper.h.

layerEnergies_

std::vector<double> HGCalShowerShapeHelper::ShowerShapeCalc::layerEnergies_

private

Definition at line 131 of file HGCalShowerShapeHelper.h.

maxLayer_

int HGCalShowerShapeHelper::ShowerShapeCalc::maxLayer_

private

Definition at line 122 of file HGCalShowerShapeHelper.h.

minHitE_

double HGCalShowerShapeHelper::ShowerShapeCalc::minHitE_

private

Definition at line 118 of file HGCalShowerShapeHelper.h.

minHitET2_

double HGCalShowerShapeHelper::ShowerShapeCalc::minHitET2_

private

Definition at line 120 of file HGCalShowerShapeHelper.h.

minHitET_

double HGCalShowerShapeHelper::ShowerShapeCalc::minHitET_

private

Definition at line 119 of file HGCalShowerShapeHelper.h.

minLayer_

int HGCalShowerShapeHelper::ShowerShapeCalc::minLayer_

private

Definition at line 121 of file HGCalShowerShapeHelper.h.

nLayer_

int HGCalShowerShapeHelper::ShowerShapeCalc::nLayer_

private

Definition at line 123 of file HGCalShowerShapeHelper.h.

Referenced by ShowerShapeCalc().

pfRecHitPtrMap_

std::shared_ptr<const std::unordered_map<uint32_t, const reco::PFRecHit *> > HGCalShowerShapeHelper::ShowerShapeCalc::pfRecHitPtrMap_

private

Definition at line 115 of file HGCalShowerShapeHelper.h.

rawEnergy_

double HGCalShowerShapeHelper::ShowerShapeCalc::rawEnergy_

private

Definition at line 116 of file HGCalShowerShapeHelper.h.

recHitTools_

std::shared_ptr<const hgcal::RecHitTools> HGCalShowerShapeHelper::ShowerShapeCalc::recHitTools_

private

Definition at line 114 of file HGCalShowerShapeHelper.h.

subDet_

DetId::Detector HGCalShowerShapeHelper::ShowerShapeCalc::subDet_

private

Definition at line 124 of file HGCalShowerShapeHelper.h.