RealisticHitToClusterAssociator Class Reference

#include <RealisticHitToClusterAssociator.h>

Classes
struct	RealisticHit

Public Member Functions
void	computeAssociation (float exclusiveFraction, bool useMCFractionsForExclEnergy, unsigned int fhOffset, unsigned int bhOffset)
void	filterHitsByDistance (float maxDistance)
void	findAndMergeInvisibleClusters (float invisibleFraction, float exclusiveFraction)
void	findCentersOfGravity ()
void	init (std::size_t numberOfHits, std::size_t numberOfSimClusters, std::size_t numberOfLayers)
void	insertHitEnergy (float energy, unsigned int hitIndex)
void	insertHitPosition (float x, float y, float z, unsigned int hitIndex)
void	insertLayerId (unsigned int layerId, unsigned int hitIndex)
void	insertSimClusterIdAndFraction (unsigned int scIdx, float fraction, unsigned int hitIndex, float associatedEnergy)
const std::vector< RealisticCluster > &	realisticClusters () const
float	XYdistanceFromMaxHit (unsigned int hitId, unsigned int clusterId)
float	XYdistanceFromPointOnSameLayer (unsigned int hitId, const Hit3DPosition &point)

Private Types
using	Hit3DPosition = std::array< float, 3 >

Static Private Member Functions
static float	getDecayLength (unsigned int layer, unsigned int fhOffset, unsigned int bhOffset)

Private Attributes
std::vector< RealisticHit >	realisticHits_
std::vector< RealisticCluster >	realisticSimClusters_

Detailed Description

Definition at line 13 of file RealisticHitToClusterAssociator.h.

Member Typedef Documentation

Hit3DPosition

using RealisticHitToClusterAssociator::Hit3DPosition = std::array<float, 3>

private

Definition at line 14 of file RealisticHitToClusterAssociator.h.

Member Function Documentation

computeAssociation()

void RealisticHitToClusterAssociator::computeAssociation ( float  exclusiveFraction, bool  useMCFractionsForExclEnergy, unsigned int  fhOffset, unsigned int  bhOffset  )

inline

Definition at line 66 of file RealisticHitToClusterAssociator.h.

                                                 {
    //if more than exclusiveFraction of a hit's energy belongs to a cluster, that rechit is not counted as shared
    unsigned int numberOfHits = realisticHits_.size();
    std::vector<float> partialEnergies;
    for (unsigned int hitId = 0; hitId < numberOfHits; ++hitId) {
      partialEnergies.clear();
      std::vector<unsigned int> removeAssociation;
      auto& realisticHit = realisticHits_[hitId];
      unsigned int numberOfClusters = realisticHit.hitToCluster_.size();
      if (numberOfClusters == 1) {
        unsigned int simClusterId = realisticHit.hitToCluster_[0].simClusterId_;
        float assignedFraction = 1.f;
        realisticHit.hitToCluster_[0].realisticEnergyFraction_ = assignedFraction;
        float assignedEnergy = realisticHit.totalEnergy_;
        realisticSimClusters_[simClusterId].increaseEnergy(assignedEnergy);
        realisticSimClusters_[simClusterId].addHitAndFraction(hitId, assignedFraction);
        realisticSimClusters_[simClusterId].increaseExclusiveEnergy(assignedEnergy);
      } else {
        partialEnergies.resize(numberOfClusters, 0.f);
        unsigned int layer = realisticHit.layerId_;
        float sumE = 0.f;
        float energyDecayLength = getDecayLength(layer, fhOffset, bhOffset);
        for (unsigned int clId = 0; clId < numberOfClusters; ++clId) {
          auto simClusterId = realisticHit.hitToCluster_[clId].simClusterId_;
          realisticHit.hitToCluster_[clId].distanceFromMaxHit_ = XYdistanceFromMaxHit(hitId, simClusterId);
          // partial energy is computed based on the distance from the maximum energy hit and its energy
          // partial energy is only needed to compute a fraction and it's not the energy assigned to the cluster
          auto maxEnergyOnLayer = realisticSimClusters_[simClusterId].getMaxEnergy(layer);
          if (maxEnergyOnLayer > 0.f) {
            partialEnergies[clId] =
                maxEnergyOnLayer * std::exp(-realisticHit.hitToCluster_[clId].distanceFromMaxHit_ / energyDecayLength);
          }
          sumE += partialEnergies[clId];
        }
        if (sumE > 0.f) {
          float invSumE = 1.f / sumE;
          for (unsigned int clId = 0; clId < numberOfClusters; ++clId) {
            unsigned int simClusterIndex = realisticHit.hitToCluster_[clId].simClusterId_;
            float assignedFraction = partialEnergies[clId] * invSumE;
            if (assignedFraction > 1e-3) {
              realisticHit.hitToCluster_[clId].realisticEnergyFraction_ = assignedFraction;
              float assignedEnergy = assignedFraction * realisticHit.totalEnergy_;
              realisticSimClusters_[simClusterIndex].increaseEnergy(assignedEnergy);
              realisticSimClusters_[simClusterIndex].addHitAndFraction(hitId, assignedFraction);
              // if the hits energy belongs for more than exclusiveFraction to a cluster, also the cluster's
              // exclusive energy is increased. The exclusive energy will be needed to evaluate if
              // a realistic cluster will be invisible, i.e. absorbed by other clusters
              if ((useMCFractionsForExclEnergy and
                   realisticHit.hitToCluster_[clId].mcEnergyFraction_ > exclusiveFraction) or
                  (!useMCFractionsForExclEnergy and assignedFraction > exclusiveFraction)) {
                realisticSimClusters_[simClusterIndex].increaseExclusiveEnergy(assignedEnergy);
              }
            } else {
              removeAssociation.push_back(simClusterIndex);
            }
          }
        }
      }
 
      while (!removeAssociation.empty()) {
        auto clusterToRemove = removeAssociation.back();
        removeAssociation.pop_back();
 
        realisticHit.hitToCluster_.erase(std::remove_if(realisticHit.hitToCluster_.begin(),
                                                        realisticHit.hitToCluster_.end(),
                                                        [clusterToRemove](const RealisticHit::HitToCluster& x) {
                                                          return x.simClusterId_ == clusterToRemove;
                                                        }),
                                         realisticHit.hitToCluster_.end());
      }
    }
  }

References MillePedeFileConverter_cfg::e, particleFlowClusterHGC_cfi::exclusiveFraction, JetChargeProducer_cfi::exp, f, getDecayLength(), phase1PixelTopology::layer, or, realisticHits_, realisticSimClusters_, particleFlowClusterHGC_cfi::useMCFractionsForExclEnergy, x, and XYdistanceFromMaxHit().

Referenced by RealisticSimClusterMapper::buildClusters().

filterHitsByDistance()

void RealisticHitToClusterAssociator::filterHitsByDistance ( float  maxDistance )

inline

Definition at line 250 of file RealisticHitToClusterAssociator.h.

                                               {
    for (auto& cluster : realisticSimClusters_) {
      if (cluster.isVisible()) {
        auto& hAndF = cluster.hitsIdsAndFractions();
        for (unsigned int i = 0; i < hAndF.size(); ++i) {
          auto hitId = hAndF[i].first;
          const auto& hit = realisticHits_[hitId];
          auto layerId = hit.layerId_;
          if (XYdistanceFromPointOnSameLayer(hitId, cluster.getCenterOfGravity(layerId)) > maxDistance) {
            cluster.increaseEnergy(-hit.totalEnergy_ * hAndF[i].second);
            cluster.modifyFractionByIndex(0.f, i);
          }
        }
      }
    }
  }

References f, mps_fire::i, particleFlowClusterHGC_cfi::maxDistance, realisticHits_, realisticSimClusters_, and XYdistanceFromPointOnSameLayer().

Referenced by RealisticSimClusterMapper::buildClusters().

findAndMergeInvisibleClusters()

void RealisticHitToClusterAssociator::findAndMergeInvisibleClusters ( float  invisibleFraction, float  exclusiveFraction  )

inline

Definition at line 142 of file RealisticHitToClusterAssociator.h.

                                                                                       {
    unsigned int numberOfRealSimClusters = realisticSimClusters_.size();
 
    for (unsigned int clId = 0; clId < numberOfRealSimClusters; ++clId) {
      if (realisticSimClusters_[clId].getExclusiveEnergyFraction() < invisibleFraction) {
        realisticSimClusters_[clId].setVisible(false);
        auto& hAndF = realisticSimClusters_[clId].hitsIdsAndFractions();
        std::unordered_map<unsigned int, float> energyInNeighbors;
        float totalSharedEnergy = 0.f;
 
        for (auto& elt : hAndF) {
          unsigned int hitId = elt.first;
          float fraction = elt.second;
          auto& realisticHit = realisticHits_[hitId];
 
          if (realisticHit.hitToCluster_.size() > 1 && fraction < 1.f) {
            float correction = 1.f - fraction;
            unsigned int numberOfClusters = realisticHit.hitToCluster_.size();
            int clusterToRemove = -1;
            for (unsigned int i = 0; i < numberOfClusters; ++i) {
              auto simClusterIndex = realisticHit.hitToCluster_[i].simClusterId_;
              if (simClusterIndex == clId) {
                clusterToRemove = i;
              } else if (realisticSimClusters_[simClusterIndex].isVisible()) {
                float oldFraction = realisticHit.hitToCluster_[i].realisticEnergyFraction_;
                float newFraction = oldFraction / correction;
                float oldEnergy = oldFraction * realisticHit.totalEnergy_;
                float newEnergy = newFraction * realisticHit.totalEnergy_;
                float sharedEnergy = newEnergy - oldEnergy;
                energyInNeighbors[simClusterIndex] += sharedEnergy;
                totalSharedEnergy += sharedEnergy;
                realisticSimClusters_[simClusterIndex].increaseEnergy(sharedEnergy);
                realisticSimClusters_[simClusterIndex].modifyFractionForHitId(newFraction, hitId);
                realisticHit.hitToCluster_[i].realisticEnergyFraction_ = newFraction;
                if (newFraction > exclusiveFraction) {
                  realisticSimClusters_[simClusterIndex].increaseExclusiveEnergy(sharedEnergy);
                  if (oldFraction <= exclusiveFraction) {
                    realisticSimClusters_[simClusterIndex].increaseExclusiveEnergy(oldEnergy);
                  }
                }
              }
            }
            realisticSimClusters_[realisticHit.hitToCluster_[clusterToRemove].simClusterId_].modifyFractionForHitId(
                0.f, hitId);
            realisticHit.hitToCluster_.erase(realisticHit.hitToCluster_.begin() + clusterToRemove);
          }
        }
 
        for (auto& elt : hAndF) {
          unsigned int hitId = elt.first;
          auto& realisticHit = realisticHits_[hitId];
          if (realisticHit.hitToCluster_.size() == 1 and realisticHit.hitToCluster_[0].simClusterId_ == clId and
              totalSharedEnergy > 0.f) {
            for (auto& pair : energyInNeighbors) {
              // hits that belonged completely to the absorbed cluster are redistributed
              // based on the fraction of energy shared in the shared hits
              float sharedFraction = pair.second / totalSharedEnergy;
              if (sharedFraction > 1e-6) {
                float assignedEnergy = realisticHit.totalEnergy_ * sharedFraction;
                realisticSimClusters_[pair.first].increaseEnergy(assignedEnergy);
                realisticSimClusters_[pair.first].addHitAndFraction(hitId, sharedFraction);
                realisticHit.hitToCluster_.emplace_back(
                    RealisticHit::HitToCluster{pair.first, 0.f, -1.f, sharedFraction});
                if (sharedFraction > exclusiveFraction)
                  realisticSimClusters_[pair.first].increaseExclusiveEnergy(assignedEnergy);
              }
            }
          }
        }
      }
    }
  }

References pfMETCorrectionType0_cfi::correction, MillePedeFileConverter_cfg::e, particleFlowClusterHGC_cfi::exclusiveFraction, f, HLT_FULL_cff::fraction, mps_fire::i, particleFlowClusterHGC_cfi::invisibleFraction, realisticHits_, realisticSimClusters_, and egamma::sharedEnergy().

Referenced by RealisticSimClusterMapper::buildClusters().

findCentersOfGravity()

void RealisticHitToClusterAssociator::findCentersOfGravity ( )

inline

Definition at line 215 of file RealisticHitToClusterAssociator.h.

                              {
    for (auto& cluster : realisticSimClusters_) {
      if (cluster.isVisible()) {
        unsigned int layersNum = cluster.getLayersNum();
        std::vector<float> totalEnergyPerLayer(layersNum, 0.f);
        std::vector<float> xEnergyPerLayer(layersNum, 0.f);
        std::vector<float> yEnergyPerLayer(layersNum, 0.f);
        std::vector<float> zPositionPerLayer(layersNum, 0.f);
        const auto& hAndF = cluster.hitsIdsAndFractions();
        for (auto& elt : hAndF) {
          auto hitId = elt.first;
          auto fraction = elt.second;
          const auto& hit = realisticHits_[hitId];
          const auto& hitPos = hit.hitPosition_;
          auto layerId = hit.layerId_;
          auto hitEinCluster = hit.totalEnergy_ * fraction;
          totalEnergyPerLayer[layerId] += hitEinCluster;
          xEnergyPerLayer[layerId] += hitPos[0] * hitEinCluster;
          yEnergyPerLayer[layerId] += hitPos[1] * hitEinCluster;
          zPositionPerLayer[layerId] = hitPos[2];
        }
        Hit3DPosition centerOfGravity;
        for (unsigned int layerId = 0; layerId < layersNum; layerId++) {
          auto energyOnLayer = totalEnergyPerLayer[layerId];
          if (energyOnLayer > 0.f) {
            centerOfGravity = {{xEnergyPerLayer[layerId] / energyOnLayer,
                                yEnergyPerLayer[layerId] / energyOnLayer,
                                zPositionPerLayer[layerId]}};
            cluster.setCenterOfGravity(layerId, centerOfGravity);
          }
        }
      }
    }
  }

References f, HLT_FULL_cff::fraction, realisticHits_, and realisticSimClusters_.

Referenced by RealisticSimClusterMapper::buildClusters().

getDecayLength()

static float RealisticHitToClusterAssociator::getDecayLength ( unsigned int  layer, unsigned int  fhOffset, unsigned int  bhOffset  )

inlinestaticprivate

Definition at line 270 of file RealisticHitToClusterAssociator.h.

                                                                                                {
    constexpr float eeDecayLengthInLayer = 2.f;
    constexpr float fhDecayLengthInLayer = 1.5f;
    constexpr float bhDecayLengthInLayer = 1.f;
 
    if (layer <= fhOffset)
      return eeDecayLengthInLayer;
    else if (layer > fhOffset && layer <= bhOffset)
      return fhDecayLengthInLayer;
    else
      return bhDecayLengthInLayer;
  }

References phase1PixelTopology::layer.

Referenced by computeAssociation().

init()

void RealisticHitToClusterAssociator::init ( std::size_t  numberOfHits, std::size_t  numberOfSimClusters, std::size_t  numberOfLayers  )

inline

Definition at line 31 of file RealisticHitToClusterAssociator.h.

                                                                                             {
    realisticHits_.resize(numberOfHits);
    realisticSimClusters_.resize(numberOfSimClusters);
    for (auto& sc : realisticSimClusters_)
      sc.setLayersNum(numberOfLayers);
  }

References numberOfLayers(), realisticHits_, and realisticSimClusters_.

Referenced by RealisticSimClusterMapper::buildClusters().

insertHitEnergy()

void RealisticHitToClusterAssociator::insertHitEnergy ( float  energy, unsigned int  hitIndex  )

inline

Definition at line 44 of file RealisticHitToClusterAssociator.h.

{ realisticHits_[hitIndex].totalEnergy_ = energy; }

References HCALHighEnergyHPDFilter_cfi::energy, and realisticHits_.

Referenced by RealisticSimClusterMapper::buildClusters().

insertHitPosition()

void RealisticHitToClusterAssociator::insertHitPosition ( float  x, float  y, float  z, unsigned int  hitIndex  )

inline

Definition at line 38 of file RealisticHitToClusterAssociator.h.

                                                                           {
    realisticHits_[hitIndex].hitPosition_ = {{x, y, z}};
  }

References realisticHits_, x, y, and z.

Referenced by RealisticSimClusterMapper::buildClusters().

insertLayerId()

void RealisticHitToClusterAssociator::insertLayerId ( unsigned int  layerId, unsigned int  hitIndex  )

inline

Definition at line 42 of file RealisticHitToClusterAssociator.h.

{ realisticHits_[hitIndex].layerId_ = layerId; }

References realisticHits_.

Referenced by RealisticSimClusterMapper::buildClusters().

insertSimClusterIdAndFraction()

void RealisticHitToClusterAssociator::insertSimClusterIdAndFraction ( unsigned int  scIdx, float  fraction, unsigned int  hitIndex, float  associatedEnergy  )

inline

Definition at line 46 of file RealisticHitToClusterAssociator.h.

                                                                                                                        {
    realisticHits_[hitIndex].hitToCluster_.emplace_back(RealisticHit::HitToCluster{scIdx, fraction, 0.f, 0.f});
    realisticSimClusters_[scIdx].setMaxEnergyHit(
        realisticHits_[hitIndex].layerId_, associatedEnergy, realisticHits_[hitIndex].hitPosition_);
  }

References HLT_FULL_cff::fraction, realisticHits_, and realisticSimClusters_.

Referenced by RealisticSimClusterMapper::buildClusters().

realisticClusters()

const std::vector<RealisticCluster>& RealisticHitToClusterAssociator::realisticClusters ( ) const

inline

Definition at line 267 of file RealisticHitToClusterAssociator.h.

{ return realisticSimClusters_; }

References realisticSimClusters_.

Referenced by RealisticSimClusterMapper::buildClusters().

XYdistanceFromMaxHit()

float RealisticHitToClusterAssociator::XYdistanceFromMaxHit ( unsigned int  hitId, unsigned int  clusterId  )

inline

Definition at line 52 of file RealisticHitToClusterAssociator.h.

                                                                         {
    auto l = realisticHits_[hitId].layerId_;
    const auto& maxHitPosition = realisticSimClusters_[clusterId].getMaxEnergyPosition(l);
    float distanceSquared = std::pow((realisticHits_[hitId].hitPosition_[0] - maxHitPosition[0]), 2) +
                            std::pow((realisticHits_[hitId].hitPosition_[1] - maxHitPosition[1]), 2);
    return std::sqrt(distanceSquared);
  }

References gpuClustering::clusterId, cmsLHEtoEOSManager::l, funct::pow(), realisticHits_, realisticSimClusters_, and mathSSE::sqrt().

Referenced by computeAssociation().

XYdistanceFromPointOnSameLayer()

float RealisticHitToClusterAssociator::XYdistanceFromPointOnSameLayer ( unsigned int  hitId, const Hit3DPosition &  point  )

inline

Definition at line 60 of file RealisticHitToClusterAssociator.h.

                                                                                       {
    float distanceSquared = std::pow((realisticHits_[hitId].hitPosition_[0] - point[0]), 2) +
                            std::pow((realisticHits_[hitId].hitPosition_[1] - point[1]), 2);
    return std::sqrt(distanceSquared);
  }

References point, funct::pow(), realisticHits_, and mathSSE::sqrt().

Referenced by filterHitsByDistance().

Member Data Documentation

realisticHits_

std::vector<RealisticHit> RealisticHitToClusterAssociator::realisticHits_

private

Definition at line 286 of file RealisticHitToClusterAssociator.h.

Referenced by computeAssociation(), filterHitsByDistance(), findAndMergeInvisibleClusters(), findCentersOfGravity(), init(), insertHitEnergy(), insertHitPosition(), insertLayerId(), insertSimClusterIdAndFraction(), XYdistanceFromMaxHit(), and XYdistanceFromPointOnSameLayer().

realisticSimClusters_

std::vector<RealisticCluster> RealisticHitToClusterAssociator::realisticSimClusters_

private

Definition at line 284 of file RealisticHitToClusterAssociator.h.

Referenced by computeAssociation(), filterHitsByDistance(), findAndMergeInvisibleClusters(), findCentersOfGravity(), init(), insertSimClusterIdAndFraction(), realisticClusters(), and XYdistanceFromMaxHit().