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