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.

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

Referenced by RealisticSimClusterMapper::buildClusters().

                                                 {
    //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());
      }
    }
  }

filterHitsByDistance()

void RealisticHitToClusterAssociator::filterHitsByDistance ( float  maxDistance )

inline

Definition at line 250 of file RealisticHitToClusterAssociator.h.

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

Referenced by RealisticSimClusterMapper::buildClusters().

                                               {
    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);
          }
        }
      }
    }
  }

findAndMergeInvisibleClusters()

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

inline

Definition at line 142 of file RealisticHitToClusterAssociator.h.

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

Referenced by RealisticSimClusterMapper::buildClusters().

                                                                                       {
    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);
              }
            }
          }
        }
      }
    }
  }

findCentersOfGravity()

void RealisticHitToClusterAssociator::findCentersOfGravity ( )

inline

Definition at line 215 of file RealisticHitToClusterAssociator.h.

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

Referenced by RealisticSimClusterMapper::buildClusters().

                              {
    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);
          }
        }
      }
    }
  }

getDecayLength()

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

inlinestaticprivate

Definition at line 270 of file RealisticHitToClusterAssociator.h.

References pixelTopology::layer.

Referenced by computeAssociation().

                                                                                                {
    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;
  }

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.

References phase1PixelTopology::numberOfLayers, realisticHits_, and realisticSimClusters_.

Referenced by RealisticSimClusterMapper::buildClusters().

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

insertHitEnergy()

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

inline

Definition at line 44 of file RealisticHitToClusterAssociator.h.

References HCALHighEnergyHPDFilter_cfi::energy, and realisticHits_.

Referenced by RealisticSimClusterMapper::buildClusters().

{ realisticHits_[hitIndex].totalEnergy_ = energy; }

insertHitPosition()

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

inline

Definition at line 38 of file RealisticHitToClusterAssociator.h.

References realisticHits_, x, y, and z.

Referenced by RealisticSimClusterMapper::buildClusters().

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

insertLayerId()

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

inline

Definition at line 42 of file RealisticHitToClusterAssociator.h.

References realisticHits_.

Referenced by RealisticSimClusterMapper::buildClusters().

{ realisticHits_[hitIndex].layerId_ = layerId; }

insertSimClusterIdAndFraction()

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

inline

Definition at line 46 of file RealisticHitToClusterAssociator.h.

References HLT_2022v15_cff::fraction, realisticHits_, and realisticSimClusters_.

Referenced by RealisticSimClusterMapper::buildClusters().

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

realisticClusters()

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

inline

Definition at line 267 of file RealisticHitToClusterAssociator.h.

References realisticSimClusters_.

Referenced by RealisticSimClusterMapper::buildClusters().

{ return realisticSimClusters_; }

XYdistanceFromMaxHit()

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

inline

Definition at line 52 of file RealisticHitToClusterAssociator.h.

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

Referenced by computeAssociation().

                                                                         {
    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);
  }

XYdistanceFromPointOnSameLayer()

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

inline

Definition at line 60 of file RealisticHitToClusterAssociator.h.

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

Referenced by filterHitsByDistance().

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

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().