TICL/plugins/TrackstersPCA.h

0001 #ifndef RECOHGCAL_TICL_TRACKSTERSPCA_H
0002 #define RECOHGCAL_TICL_TRACKSTERSPCA_H
0003
0004 #include "DataFormats/HGCalReco/interface/Trackster.h"
0005 #include "DataFormats/CaloRecHit/interface/CaloCluster.h"
0006 #include <vector>
0007 #include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h"
0008
0009 namespace ticl {
0010   /**
0011    * Computes the trackster raw energy, barycenter, timing, PCA.
0012    * PCA is computed using layer cluster positions (and energies if energyWeight=True)
0013    * In case clean=True: Only the most energetic layer cluster on each layer is considered,
0014    *   and only layers in range around the most energetic layer cluster
0015    * \param z_limit_em Limit between EM and HAD section (in absolute value)
0016    * \param energyWeight Compute energy-weighted barycenter and PCA
0017    * \param clean Use the PCA cleaning algorithm.
0018    * \param minLayer Number of layers to consider for cleaned PCA behind the most energetic LC
0019    * \param maxLayer Number of layers to consider for cleaned PCA after the most energetic LC
0020    */
0021   void assignPCAtoTracksters(std::vector<Trackster> &tracksters,
0022                              const std::vector<reco::CaloCluster> &layerClusters,
0023                              const edm::ValueMap<std::pair<float, float>> &layerClustersTime,
0024                              double z_limit_em,
0025                              hgcal::RecHitTools const &rhTools,
0026                              bool computeLocalTime = false,
0027                              bool energyWeight = true,
0028                              bool clean = false,
0029                              int minLayer = 10,
0030                              int maxLayer = 10);
0031   std::pair<float, float> computeLocalTracksterTime(const Trackster &trackster,
0032                                                     const std::vector<reco::CaloCluster> &layerClusters,
0033                                                     const edm::ValueMap<std::pair<float, float>> &layerClustersTime,
0034                                                     const Eigen::Vector3f &barycenter,
0035                                                     size_t N);
0036   std::pair<float, float> computeTracksterTime(const Trackster &trackster,
0037                                                const edm::ValueMap<std::pair<float, float>> &layerClustersTime,
0038                                                size_t N);
0039
0040   inline unsigned getLayerFromLC(const reco::CaloCluster &LC, const hgcal::RecHitTools &rhtools) {
0041     std::vector<std::pair<DetId, float>> thisclusterHits = LC.hitsAndFractions();
0042     auto layer = rhtools.getLayerWithOffset(thisclusterHits[0].first);
0043     return layer;
0044   }
0045
0046   // Sort the layer clusters in the given trackster in bins of layer. Returns : vector[index=layer, value=vector[LC index]]]
0047   inline std::vector<std::vector<unsigned>> sortByLayer(const Trackster &ts,
0048                                                         const std::vector<reco::CaloCluster> &layerClusters,
0049                                                         const hgcal::RecHitTools &rhtools) {
0050     size_t N = ts.vertices().size();
0051
0052     std::vector<std::vector<unsigned>> result;
0053     result.resize(rhtools.lastLayer() + 1);
0054
0055     for (unsigned i = 0; i < N; ++i) {
0056       const auto &thisLC = layerClusters[ts.vertices(i)];
0057       auto layer = getLayerFromLC(thisLC, rhtools);
0058       result[layer].push_back(i);
0059     }
0060     return result;
0061   }
0062 }  // namespace ticl
0063 #endif