#include <HGCalShowerShape.h>

Classes
struct	DeltaPhi

Public Types
typedef math::XYZTLorentzVector	LorentzVector

Public Member Functions
int	coreShowerLength (const l1t::HGCalMulticluster &c3d, const HGCalTriggerGeometryBase &triggerGeometry) const

float	eMax (const l1t::HGCalMulticluster &c3d) const

void	eventSetup (const edm::EventSetup &es)

void	fillShapes (l1t::HGCalMulticluster &, const HGCalTriggerGeometryBase &) const

int	firstLayer (const l1t::HGCalMulticluster &c3d) const

	HGCalShowerShape ()

int	lastLayer (const l1t::HGCalMulticluster &c3d) const

int	maxLayer (const l1t::HGCalMulticluster &c3d) const

int	showerLength (const l1t::HGCalMulticluster &c3d) const

float	sigmaEtaEtaMax (const l1t::HGCalMulticluster &c3d) const

float	sigmaEtaEtaTot (const l1t::HGCalMulticluster &c3d) const

float	sigmaEtaEtaTot (const l1t::HGCalCluster &c2d) const

float	sigmaPhiPhiMax (const l1t::HGCalMulticluster &c3d) const

float	sigmaPhiPhiTot (const l1t::HGCalMulticluster &c3d) const

float	sigmaPhiPhiTot (const l1t::HGCalCluster &c2d) const

float	sigmaRRMax (const l1t::HGCalMulticluster &c3d) const

float	sigmaRRMean (const l1t::HGCalMulticluster &c3d, float radius=5.) const

float	sigmaRRTot (const l1t::HGCalMulticluster &c3d) const

float	sigmaRRTot (const l1t::HGCalCluster &c2d) const

float	sigmaZZ (const l1t::HGCalMulticluster &c3d) const

	~HGCalShowerShape ()

Private Member Functions
float	meanX (const std::vector< pair< float, float >> &energy_X_tc) const

float	sigmaPhiPhi (const std::vector< pair< float, float >> &energy_phi_tc, const float phi_cluster) const

template<typename Delta = std::minus<float>>
float	sigmaXX (const std::vector< pair< float, float >> &energy_X_tc, const float X_cluster) const

Private Attributes
HGCalTriggerTools	triggerTools_

Detailed Description

Definition at line 12 of file HGCalShowerShape.h.

Member Typedef Documentation

typedef math::XYZTLorentzVector HGCalShowerShape::LorentzVector

Definition at line 14 of file HGCalShowerShape.h.

Constructor & Destructor Documentation

HGCalShowerShape::HGCalShowerShape ( )

inline

Definition at line 16 of file HGCalShowerShape.h.

16 {}

HGCalShowerShape::~HGCalShowerShape ( )

inline

Definition at line 18 of file HGCalShowerShape.h.

18 {}

Member Function Documentation

int HGCalShowerShape::coreShowerLength	(	const l1t::HGCalMulticluster &	c3d,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)		const

Definition at line 70 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), ForwardEmpty, LayerTriplets::layers(), HGCalTriggerTools::layers(), nlayers, HGCalTriggerGeometryBase::triggerLayer(), and triggerTools_.

Referenced by fillShapes(), and showerLength().

                                                                                               {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
   unsigned nlayers = triggerTools_.layers(ForwardSubdetector::ForwardEmpty);
   std::vector<bool> layers(nlayers);
   for (const auto& id_cluster : clustersPtrs) {
     unsigned layer = triggerGeometry.triggerLayer(id_cluster.second->detId());
     if (layer == 0 || layer > nlayers)
       continue;
     layers[layer - 1] = true;  //layer 0 doesn't exist, so shift by -1
   }
   int length = 0;
   int maxlength = 0;
   for (bool layer : layers) {
     if (layer)
       length++;
     else
       length = 0;
     if (length > maxlength)
       maxlength = length;
   }
   return maxlength;
 }

float HGCalShowerShape::eMax ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 299 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), HGCalTriggerTools::layerWithOffset(), and triggerTools_.

Referenced by fillShapes(), and showerLength().

                                                                   {
   std::unordered_map<int, float> layer_energy;
 
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   for (const auto& id_clu : clustersPtrs) {
     unsigned layer = triggerTools_.layerWithOffset(id_clu.second->detId());
     layer_energy[layer] += id_clu.second->energy();
   }
 
   float EMax = 0;
 
   for (const auto& layer : layer_energy) {
     if (layer.second > EMax)
       EMax = layer.second;
   }
 
   return EMax;
 }

void HGCalShowerShape::eventSetup ( const edm::EventSetup & es )

inline

Definition at line 20 of file HGCalShowerShape.h.

References HGCalTriggerTools::eventSetup(), firstLayer(), lastLayer(), maxLayer(), and triggerTools_.

Referenced by HGCalHistoClusteringImpl::eventSetup(), and HGCalMulticlusteringImpl::eventSetup().

20 { triggerTools_.eventSetup(es); }

HGCalTriggerTools::eventSetup

void eventSetup(const edm::EventSetup &)

Definition: HGCalTriggerTools.cc:33

HGCalShowerShape::triggerTools_

HGCalTriggerTools triggerTools_

Definition: HGCalShowerShape.h:78

void HGCalShowerShape::fillShapes	(	l1t::HGCalMulticluster &	c3d,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)		const

Definition at line 385 of file HGCalShowerShape.cc.

Referenced by HGCalMulticlusteringImpl::finalizeClusters(), HGCalHistoClusteringImpl::finalizeClusters(), and showerLength().

                                                                                                                   {
   c3d.showerLength(showerLength(c3d));
   c3d.coreShowerLength(coreShowerLength(c3d, triggerGeometry));
   c3d.firstLayer(firstLayer(c3d));
   c3d.maxLayer(maxLayer(c3d));
   c3d.sigmaEtaEtaTot(sigmaEtaEtaTot(c3d));
   c3d.sigmaEtaEtaMax(sigmaEtaEtaMax(c3d));
   c3d.sigmaPhiPhiTot(sigmaPhiPhiTot(c3d));
   c3d.sigmaPhiPhiMax(sigmaPhiPhiMax(c3d));
   c3d.sigmaZZ(sigmaZZ(c3d));
   c3d.sigmaRRTot(sigmaRRTot(c3d));
   c3d.sigmaRRMax(sigmaRRMax(c3d));
   c3d.sigmaRRMean(sigmaRRMean(c3d));
   c3d.eMax(eMax(c3d));
 }

int HGCalShowerShape::firstLayer ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 25 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), HGCalTriggerTools::layerWithOffset(), and triggerTools_.

Referenced by eventSetup(), fillShapes(), and showerLength().

                                                                       {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   int firstLayer = 999;
 
   for (const auto& id_clu : clustersPtrs) {
     int layer = triggerTools_.layerWithOffset(id_clu.second->detId());
     if (layer < firstLayer)
       firstLayer = layer;
   }
 
   return firstLayer;
 }

int HGCalShowerShape::lastLayer ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 56 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), HGCalTriggerTools::layerWithOffset(), and triggerTools_.

Referenced by eventSetup(), and showerLength().

                                                                      {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   int lastLayer = -999;
 
   for (const auto& id_clu : clustersPtrs) {
     int layer = triggerTools_.layerWithOffset(id_clu.second->detId());
     if (layer > lastLayer)
       lastLayer = layer;
   }
 
   return lastLayer;
 }

int HGCalShowerShape::maxLayer ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 39 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), HGCalTriggerTools::layerWithOffset(), and triggerTools_.

Referenced by eventSetup(), and fillShapes().

                                                                     {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
   std::unordered_map<int, float> layers_pt;
   float max_pt = 0.;
   int max_layer = 0;
   for (const auto& id_cluster : clustersPtrs) {
     unsigned layer = triggerTools_.layerWithOffset(id_cluster.second->detId());
     auto itr_insert = layers_pt.emplace(layer, 0.);
     itr_insert.first->second += id_cluster.second->pt();
     if (itr_insert.first->second > max_pt) {
       max_pt = itr_insert.first->second;
       max_layer = layer;
     }
   }
   return max_layer;
 }

float HGCalShowerShape::meanX ( const std::vector< pair< float, float >> & energy_X_tc ) const

private

Definition at line 10 of file HGCalShowerShape.cc.

Referenced by showerLength(), sigmaRRMax(), sigmaRRMean(), sigmaRRTot(), and sigmaZZ().

                                                                                     {
   float Etot = 0;
   float X_sum = 0;
 
   for (const auto& energy_X : energy_X_tc) {
     X_sum += energy_X.first * energy_X.second;
     Etot += energy_X.first;
   }
 
   float X_mean = 0;
   if (Etot > 0)
     X_mean = X_sum / Etot;
   return X_mean;
 }

int HGCalShowerShape::showerLength ( const l1t::HGCalMulticluster & c3d ) const

inline

Definition at line 25 of file HGCalShowerShape.h.

References coreShowerLength(), eMax(), fillShapes(), firstLayer(), lastLayer(), meanX(), TCMET_cfi::radius, sigmaEtaEtaMax(), sigmaEtaEtaTot(), sigmaPhiPhiMax(), sigmaPhiPhiTot(), sigmaRRMax(), sigmaRRMean(), sigmaRRTot(), and sigmaZZ().

Referenced by fillShapes().

                                                           {
     return lastLayer(c3d) - firstLayer(c3d) + 1;
   }  //in number of layers

float HGCalShowerShape::sigmaEtaEtaMax ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 153 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), HGCalTriggerTools::layerWithOffset(), sigmaXX(), and triggerTools_.

Referenced by fillShapes(), and showerLength().

                                                                             {
   std::unordered_map<int, std::vector<std::pair<float, float>>> tc_layer_energy_eta;
   std::unordered_map<int, LorentzVector> layer_LV;
 
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   for (const auto& id_clu : clustersPtrs) {
     unsigned layer = triggerTools_.layerWithOffset(id_clu.second->detId());
 
     layer_LV[layer] += id_clu.second->p4();
 
     const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& triggerCells = id_clu.second->constituents();
 
     for (const auto& id_tc : triggerCells) {
       tc_layer_energy_eta[layer].emplace_back(std::make_pair(id_tc.second->energy(), id_tc.second->eta()));
     }
   }
 
   float SigmaEtaEtaMax = 0;
 
   for (auto& tc_iter : tc_layer_energy_eta) {
     const std::vector<std::pair<float, float>>& energy_eta_layer = tc_iter.second;
     const LorentzVector& LV_layer = layer_LV[tc_iter.first];
     float SigmaEtaEtaLayer = sigmaXX(energy_eta_layer, LV_layer.eta());  //RMS wrt layer eta, not wrt c3d eta
     if (SigmaEtaEtaLayer > SigmaEtaEtaMax)
       SigmaEtaEtaMax = SigmaEtaEtaLayer;
   }
 
   return SigmaEtaEtaMax;
 }

float HGCalShowerShape::sigmaEtaEtaTot ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 94 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), reco::LeafCandidate::eta(), and sigmaXX().

Referenced by fillShapes(), and showerLength().

                                                                             {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   std::vector<std::pair<float, float>> tc_energy_eta;
 
   for (const auto& id_clu : clustersPtrs) {
     const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& triggerCells = id_clu.second->constituents();
 
     for (const auto& id_tc : triggerCells) {
       tc_energy_eta.emplace_back(std::make_pair(id_tc.second->energy(), id_tc.second->eta()));
     }
   }
 
   float SeeTot = sigmaXX(tc_energy_eta, c3d.eta());
 
   return SeeTot;
 }

float HGCalShowerShape::sigmaEtaEtaTot ( const l1t::HGCalCluster & c2d ) const

Definition at line 338 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), reco::LeafCandidate::eta(), and sigmaXX().

                                                                        {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& cellsPtrs = c2d.constituents();
 
   std::vector<std::pair<float, float>> tc_energy_eta;
 
   for (const auto& id_cell : cellsPtrs) {
     tc_energy_eta.emplace_back(std::make_pair(id_cell.second->energy(), id_cell.second->eta()));
   }
 
   float See = sigmaXX(tc_energy_eta, c2d.eta());
 
   return See;
 }

float HGCalShowerShape::sigmaPhiPhi	(	const std::vector< pair< float, float >> &	energy_phi_tc,
		const float	phi_cluster
	)		const

inlineprivate

Definition at line 74 of file HGCalShowerShape.h.

Referenced by sigmaPhiPhiMax(), and sigmaPhiPhiTot().

                                                                                                        {
     return sigmaXX<DeltaPhi<float>>(energy_phi_tc, phi_cluster);
   }

float HGCalShowerShape::sigmaPhiPhiMax ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 184 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), HGCalTriggerTools::layerWithOffset(), sigmaPhiPhi(), and triggerTools_.

Referenced by fillShapes(), and showerLength().

                                                                             {
   std::unordered_map<int, std::vector<std::pair<float, float>>> tc_layer_energy_phi;
   std::unordered_map<int, LorentzVector> layer_LV;
 
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   for (const auto& id_clu : clustersPtrs) {
     unsigned layer = triggerTools_.layerWithOffset(id_clu.second->detId());
 
     layer_LV[layer] += id_clu.second->p4();
 
     const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& triggerCells = id_clu.second->constituents();
 
     for (const auto& id_tc : triggerCells) {
       tc_layer_energy_phi[layer].emplace_back(std::make_pair(id_tc.second->energy(), id_tc.second->phi()));
     }
   }
 
   float SigmaPhiPhiMax = 0;
 
   for (auto& tc_iter : tc_layer_energy_phi) {
     const std::vector<std::pair<float, float>>& energy_phi_layer = tc_iter.second;
     const LorentzVector& LV_layer = layer_LV[tc_iter.first];
     float SigmaPhiPhiLayer = sigmaPhiPhi(energy_phi_layer, LV_layer.phi());  //RMS wrt layer phi, not wrt c3d phi
     if (SigmaPhiPhiLayer > SigmaPhiPhiMax)
       SigmaPhiPhiMax = SigmaPhiPhiLayer;
   }
 
   return SigmaPhiPhiMax;
 }

float HGCalShowerShape::sigmaPhiPhiTot ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 112 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), reco::LeafCandidate::phi(), and sigmaPhiPhi().

Referenced by fillShapes(), and showerLength().

                                                                             {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   std::vector<std::pair<float, float>> tc_energy_phi;
 
   for (const auto& id_clu : clustersPtrs) {
     const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& triggerCells = id_clu.second->constituents();
 
     for (const auto& id_tc : triggerCells) {
       tc_energy_phi.emplace_back(std::make_pair(id_tc.second->energy(), id_tc.second->phi()));
     }
   }
 
   float SppTot = sigmaPhiPhi(tc_energy_phi, c3d.phi());
 
   return SppTot;
 }

float HGCalShowerShape::sigmaPhiPhiTot ( const l1t::HGCalCluster & c2d ) const

Definition at line 352 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), reco::LeafCandidate::phi(), and sigmaPhiPhi().

                                                                        {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& cellsPtrs = c2d.constituents();
 
   std::vector<std::pair<float, float>> tc_energy_phi;
 
   for (const auto& id_cell : cellsPtrs) {
     tc_energy_phi.emplace_back(std::make_pair(id_cell.second->energy(), id_cell.second->phi()));
   }
 
   float Spp = sigmaPhiPhi(tc_energy_phi, c2d.phi());
 
   return Spp;
 }

float HGCalShowerShape::sigmaRRMax ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 215 of file HGCalShowerShape.cc.

References funct::abs(), l1t::HGCalClusterT< C >::constituents(), HGCalTriggerTools::layerWithOffset(), meanX(), funct::pow(), alignCSCRings::r, sigmaXX(), mathSSE::sqrt(), and triggerTools_.

Referenced by fillShapes(), and showerLength().

                                                                         {
   std::unordered_map<int, std::vector<std::pair<float, float>>> tc_layer_energy_r;
 
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   for (const auto& id_clu : clustersPtrs) {
     unsigned layer = triggerTools_.layerWithOffset(id_clu.second->detId());
 
     const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& triggerCells = id_clu.second->constituents();
 
     for (const auto& id_tc : triggerCells) {
       float r = (id_tc.second->position().z() != 0.
                      ? std::sqrt(pow(id_tc.second->position().x(), 2) + pow(id_tc.second->position().y(), 2)) /
                            std::abs(id_tc.second->position().z())
                      : 0.);
       tc_layer_energy_r[layer].emplace_back(std::make_pair(id_tc.second->energy(), r));
     }
   }
 
   float SigmaRRMax = 0;
 
   for (auto& tc_iter : tc_layer_energy_r) {
     const std::vector<std::pair<float, float>>& energy_r_layer = tc_iter.second;
     float r_mean_layer = meanX(energy_r_layer);
     float SigmaRRLayer = sigmaXX(energy_r_layer, r_mean_layer);
     if (SigmaRRLayer > SigmaRRMax)
       SigmaRRMax = SigmaRRLayer;
   }
 
   return SigmaRRMax;
 }

float HGCalShowerShape::sigmaRRMean	(	const l1t::HGCalMulticluster &	c3d,
		float	radius = `5.`
	)		const

Definition at line 247 of file HGCalShowerShape.cc.

References funct::abs(), l1t::HGCalClusterT< C >::constituents(), PVValHelper::dx, PVValHelper::dy, reco::LeafCandidate::energy(), HGCalTriggerTools::layerWithOffset(), meanX(), l1t::HGCalTriggerCell::position(), alignCSCRings::r, sigmaXX(), mathSSE::sqrt(), triggerTools_, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by fillShapes(), and showerLength().

                                                                                        {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
   // group trigger cells by layer
   std::unordered_map<int, std::vector<edm::Ptr<l1t::HGCalTriggerCell>>> layers_tcs;
   for (const auto& id_clu : clustersPtrs) {
     unsigned layer = triggerTools_.layerWithOffset(id_clu.second->detId());
     const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& triggerCells = id_clu.second->constituents();
     for (const auto& id_tc : triggerCells) {
       layers_tcs[layer].emplace_back(id_tc.second);
     }
   }
 
   // Select trigger cells within X cm of the max TC in the layer
   std::unordered_map<int, std::vector<std::pair<float, float>>> tc_layers_energy_r;
   for (const auto& layer_tcs : layers_tcs) {
     int layer = layer_tcs.first;
     edm::Ptr<l1t::HGCalTriggerCell> max_tc = layer_tcs.second.front();
     for (const auto& tc : layer_tcs.second) {
       if (tc->energy() > max_tc->energy())
         max_tc = tc;
     }
     for (const auto& tc : layer_tcs.second) {
       double dx = tc->position().x() - max_tc->position().x();
       double dy = tc->position().y() - max_tc->position().y();
       double distance_to_max = std::sqrt(dx * dx + dy * dy);
       if (distance_to_max < radius) {
         float r = (tc->position().z() != 0.
                        ? std::sqrt(tc->position().x() * tc->position().x() + tc->position().y() * tc->position().y()) /
                              std::abs(tc->position().z())
                        : 0.);
         tc_layers_energy_r[layer].emplace_back(std::make_pair(tc->energy(), r));
       }
     }
   }
 
   // Compute srr layer by layer
   std::vector<std::pair<float, float>> layers_energy_srr2;
   for (const auto& layer_energy_r : tc_layers_energy_r) {
     const auto& energies_r = layer_energy_r.second;
     float r_mean_layer = meanX(energies_r);
     float srr = sigmaXX(energies_r, r_mean_layer);
     double energy_sum = 0.;
     for (const auto& energy_r : energies_r) {
       energy_sum += energy_r.first;
     }
     layers_energy_srr2.emplace_back(std::make_pair(energy_sum, srr * srr));
   }
   // Combine all layer srr
   float srr2_mean = meanX(layers_energy_srr2);
   return std::sqrt(srr2_mean);
 }

float HGCalShowerShape::sigmaRRTot ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 130 of file HGCalShowerShape.cc.

References funct::abs(), l1t::HGCalClusterT< C >::constituents(), meanX(), funct::pow(), alignCSCRings::r, sigmaXX(), and mathSSE::sqrt().

Referenced by fillShapes(), and showerLength().

                                                                         {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   std::vector<std::pair<float, float>> tc_energy_r;
 
   for (const auto& id_clu : clustersPtrs) {
     const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& triggerCells = id_clu.second->constituents();
 
     for (const auto& id_tc : triggerCells) {
       float r = (id_tc.second->position().z() != 0.
                      ? std::sqrt(pow(id_tc.second->position().x(), 2) + pow(id_tc.second->position().y(), 2)) /
                            std::abs(id_tc.second->position().z())
                      : 0.);
       tc_energy_r.emplace_back(std::make_pair(id_tc.second->energy(), r));
     }
   }
 
   float r_mean = meanX(tc_energy_r);
   float Szz = sigmaXX(tc_energy_r, r_mean);
 
   return Szz;
 }

float HGCalShowerShape::sigmaRRTot ( const l1t::HGCalCluster & c2d ) const

Definition at line 366 of file HGCalShowerShape.cc.

References funct::abs(), l1t::HGCalClusterT< C >::constituents(), meanX(), funct::pow(), alignCSCRings::r, sigmaXX(), and mathSSE::sqrt().

                                                                    {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& cellsPtrs = c2d.constituents();
 
   std::vector<std::pair<float, float>> tc_energy_r;
 
   for (const auto& id_cell : cellsPtrs) {
     float r = (id_cell.second->position().z() != 0.
                    ? std::sqrt(pow(id_cell.second->position().x(), 2) + pow(id_cell.second->position().y(), 2)) /
                          std::abs(id_cell.second->position().z())
                    : 0.);
     tc_energy_r.emplace_back(std::make_pair(id_cell.second->energy(), r));
   }
 
   float r_mean = meanX(tc_energy_r);
   float Srr = sigmaXX(tc_energy_r, r_mean);
 
   return Srr;
 }

template<typename Delta = std::minus<float>>

float HGCalShowerShape::sigmaXX	(	const std::vector< pair< float, float >> &	energy_X_tc,
		const float	X_cluster
	)		const

inlineprivate

Definition at line 55 of file HGCalShowerShape.h.

References delta, funct::pow(), and mathSSE::sqrt().

Referenced by sigmaEtaEtaMax(), sigmaEtaEtaTot(), sigmaRRMax(), sigmaRRMean(), sigmaRRTot(), and sigmaZZ().

                                                                                                {
     Delta delta;
     float Etot = 0;
     float deltaX2_sum = 0;
     for (const auto& energy_X : energy_X_tc) {
       deltaX2_sum += energy_X.first * pow(delta(energy_X.second, X_cluster), 2);
       Etot += energy_X.first;
     }
     float X_MSE = 0;
     if (Etot > 0)
       X_MSE = deltaX2_sum / Etot;
     float X_RMS = sqrt(X_MSE);
     return X_RMS;
   }

float HGCalShowerShape::sigmaZZ ( const l1t::HGCalMulticluster & c3d ) const

Definition at line 319 of file HGCalShowerShape.cc.

References l1t::HGCalClusterT< C >::constituents(), meanX(), and sigmaXX().

Referenced by fillShapes(), and showerLength().

                                                                      {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clustersPtrs = c3d.constituents();
 
   std::vector<std::pair<float, float>> tc_energy_z;
 
   for (const auto& id_clu : clustersPtrs) {
     const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& triggerCells = id_clu.second->constituents();
 
     for (const auto& id_tc : triggerCells) {
       tc_energy_z.emplace_back(std::make_pair(id_tc.second->energy(), id_tc.second->position().z()));
     }
   }
 
   float z_mean = meanX(tc_energy_z);
   float Szz = sigmaXX(tc_energy_z, z_mean);
 
   return Szz;
 }

Member Data Documentation

HGCalTriggerTools HGCalShowerShape::triggerTools_

private

Definition at line 78 of file HGCalShowerShape.h.

Referenced by coreShowerLength(), eMax(), eventSetup(), firstLayer(), lastLayer(), maxLayer(), sigmaEtaEtaMax(), sigmaPhiPhiMax(), sigmaRRMax(), and sigmaRRMean().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation