RealisticCluster.h

Go to the documentation of this file.

#ifndef __RecoParticleFlow_PFClusterProducer_RealisticCluster_H__
#define __RecoParticleFlow_PFClusterProducer_RealisticCluster_H__
 
#include <array>
#include <vector>
#include <algorithm>
 
class RealisticCluster {
  using Hit3DPosition = std::array<float, 3>;
 
public:
  // for each SimCluster and for each layer, we store the position of the most energetic hit of the simcluster in the layer
 
  struct LayerInfo {
    Hit3DPosition centerOfGravityAtLayer_;
    Hit3DPosition maxHitPosAtLayer_;
    float maxEnergyHitAtLayer_;
  };
 
  RealisticCluster() : totalEnergy(0.f), exclusiveEnergy(0.f), visible(true) {}
 
  void increaseEnergy(float value) { totalEnergy += value; }
  void increaseExclusiveEnergy(float value) { exclusiveEnergy += value; }
 
  float getExclusiveEnergyFraction() const {
    float fraction = 0.f;
    if (totalEnergy > 0.f) {
      fraction = exclusiveEnergy / totalEnergy;
    }
    return fraction;
  }
 
  float getEnergy() const { return totalEnergy; }
 
  float getExclusiveEnergy() const { return exclusiveEnergy; }
 
  bool isVisible() const { return visible; }
 
  void setVisible(bool vis) { visible = vis; }
 
  void setCenterOfGravity(unsigned int layerId, const Hit3DPosition& position) {
    layerInfo_[layerId].centerOfGravityAtLayer_ = position;
  }
 
  Hit3DPosition getCenterOfGravity(unsigned int layerId) const { return layerInfo_[layerId].centerOfGravityAtLayer_; }
 
  bool setMaxEnergyHit(unsigned int layerId, float newEnergy, const Hit3DPosition position) {
    if (newEnergy > layerInfo_[layerId].maxEnergyHitAtLayer_) {
      layerInfo_[layerId].maxEnergyHitAtLayer_ = newEnergy;
      layerInfo_[layerId].maxHitPosAtLayer_ = position;
      return true;
    } else
      return false;
  }
 
  Hit3DPosition getMaxEnergyPosition(unsigned int layerId) const { return layerInfo_[layerId].maxHitPosAtLayer_; }
 
  float getMaxEnergy(unsigned int layerId) const { return layerInfo_[layerId].maxEnergyHitAtLayer_; }
 
  void setLayersNum(unsigned int numberOfLayers) { layerInfo_.resize(numberOfLayers); }
 
  unsigned int getLayersNum() const { return layerInfo_.size(); }
 
  void addHitAndFraction(unsigned int hit, float fraction) { hitIdsAndFractions_.emplace_back(hit, fraction); }
 
  void modifyFractionForHitId(float fraction, unsigned int hitId) {
    auto it = std::find_if(hitIdsAndFractions_.begin(),
                           hitIdsAndFractions_.end(),
                           [&hitId](const std::pair<unsigned int, float>& element) { return element.first == hitId; });
 
    it->second = fraction;
  }
 
  void modifyFractionByIndex(float fraction, unsigned int index) { hitIdsAndFractions_[index].second = fraction; }
 
  const std::vector<std::pair<unsigned int, float> >& hitsIdsAndFractions() const { return hitIdsAndFractions_; }
 
private:
  std::vector<std::pair<unsigned int, float> > hitIdsAndFractions_;
  std::vector<LayerInfo> layerInfo_;
 
  float totalEnergy;
  float exclusiveEnergy;
  bool visible;
};
 
#endif