CaloCluster.h

Go to the documentation of this file.

#ifndef DataFormats_CaloRecHit_CaloCluster_h
#define DataFormats_CaloRecHit_CaloCluster_h

#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/CaloRecHit/interface/CaloID.h"

#include "DataFormats/DetId/interface/DetId.h"

#include <vector>
#include <string>
#include <iostream>

namespace reco {


  class CaloCluster {
  public:
    
    enum AlgoId { island = 0, hybrid = 1, fixedMatrix = 2, dynamicHybrid = 3, multi5x5 = 4, particleFlow = 5,  undefined = 1000};

    // super-cluster flags
    enum SCFlags { cleanOnly = 0, common = 100, uncleanOnly = 200 };

   //FIXME:  
   //temporary fix... to be removed before 310 final
   typedef AlgoId AlgoID ;
 
    CaloCluster() : 
      energy_(0), correctedEnergy_(-1.0), correctedEnergyUncertainty_(-1.0), 
      algoID_( undefined ), flags_(0) {}

    CaloCluster(AlgoID algoID) : 
      energy_(0), correctedEnergy_(-1.0), correctedEnergyUncertainty_(-1.0),
      algoID_( algoID ), flags_(0) {}

    CaloCluster( double energy,
                 const math::XYZPoint& position,
                 const CaloID& caloID) :
      energy_ (energy), correctedEnergy_(-1.0), correctedEnergyUncertainty_(-1.0), position_ (position), caloID_(caloID),algoID_( undefined ), flags_(0) {}


    void reset();
    
     CaloCluster( double energy,  
         const math::XYZPoint& position ) : 
       energy_ (energy), correctedEnergy_(-1.0), position_ (position),algoID_( undefined ), flags_(0) {} 


    CaloCluster( double energy,
         const math::XYZPoint& position,
         const CaloID& caloID,
                 const AlgoID& algoID,
                 uint32_t flags = 0) :
      energy_ (energy), correctedEnergy_(-1.0), position_ (position), 
      caloID_(caloID), algoID_(algoID) {
      flags_=flags&flagsMask_;
    }

    CaloCluster( double energy,
                 const math::XYZPoint& position,
                 const CaloID& caloID,
                 const std::vector< std::pair< DetId, float > > &usedHitsAndFractions,
                 const AlgoId algoId,
         const DetId seedId = DetId(0),
                 uint32_t flags = 0) :
      energy_ (energy), correctedEnergy_(-1.0), position_ (position), caloID_(caloID), 
      hitsAndFractions_(usedHitsAndFractions), algoID_(algoId),seedId_(seedId){
      flags_=flags&flagsMask_;
    }

   //FIXME:
    CaloCluster( double energy,
                 const math::XYZPoint& position,
                 float chi2,
                 const std::vector<DetId > &usedHits,
                 const AlgoId algoId,
                 uint32_t flags = 0) :
      energy_(energy), correctedEnergy_(-1.0), position_ (position),  algoID_(algoId)
       {
          hitsAndFractions_.reserve(usedHits.size());
          for(size_t i = 0; i < usedHits.size(); i++) hitsAndFractions_.push_back(std::pair< DetId, float > ( usedHits[i],1.));
      flags_=flags&flagsMask_;
      }


    virtual ~CaloCluster() {}


    void setEnergy(double energy){energy_ = energy;}
    void setCorrectedEnergy(double cenergy){correctedEnergy_ = cenergy;}
    void setCorrectedEnergyUncertainty(float energyerr) { correctedEnergyUncertainty_ = energyerr; }
    
    void setPosition(const math::XYZPoint& p){position_ = p;}

    void setCaloId(const CaloID& id) {caloID_= id;}

    void setAlgoId(const AlgoId& id) {algoID_=id;}

    void setSeed(const DetId& id) {seedId_=id;}

    double energy() const { return energy_; }
    double correctedEnergy() const { return correctedEnergy_; }
    float correctedEnergyUncertainty() const { return correctedEnergyUncertainty_; }

    const math::XYZPoint & position() const { return position_; }
    
    bool operator >=(const CaloCluster& rhs) const { 
      return (energy_>=rhs.energy_); 
    }

    bool operator > (const CaloCluster& rhs) const { 
      return (energy_> rhs.energy_); 
    }

    bool operator <=(const CaloCluster& rhs) const { 
      return (energy_<=rhs.energy_); 
    }

    bool operator < (const CaloCluster& rhs) const { 
      return (energy_< rhs.energy_); 
    }

     bool operator==(const CaloCluster& rhs) const { 
             return (energy_ == rhs.energy_); 
     }; 

    double x() const { return position_.x(); }

    double y() const { return position_.y(); }

    double z() const { return position_.z(); }

    double eta() const { return position_.eta(); }

    double phi() const { return position_.phi(); }

    size_t size() const { return hitsAndFractions_.size(); }

    AlgoId algo() const { return algoID_; }
    AlgoID algoID() const { return algo(); }

    uint32_t flags() const { return flags_&flagsMask_; }
    void setFlags( uint32_t flags) { 
      uint32_t reserved = (flags_ & ~flagsMask_);
      flags_ = (reserved ) | (flags & flagsMask_); 
    }
    bool isInClean()   const { return flags() < uncleanOnly; }
    bool isInUnclean() const { return flags() >= common; }

    const CaloID& caloID() const {return caloID_;}

    void addHitAndFraction( DetId id, float fraction ) { 
            hitsAndFractions_.push_back( std::pair<DetId, float>(id, fraction) );
    }

    const std::vector< std::pair<DetId, float> > & hitsAndFractions() const { return hitsAndFractions_; }
    
    std::string printHitAndFraction(unsigned i) const;

    friend std::ostream& operator<<(std::ostream& out, 
                    const CaloCluster& cluster);

    DetId seed() const { return seedId_; }

  protected:

    double              energy_;
    double              correctedEnergy_;
    float               correctedEnergyUncertainty_;

    math::XYZPoint      position_;

    CaloID              caloID_;
    
    // used hits by detId
    std::vector< std::pair<DetId, float> > hitsAndFractions_;

    // cluster algorithm Id
    AlgoID              algoID_;

    DetId       seedId_;

    uint32_t            flags_;

    static const uint32_t flagsMask_  =0x0FFFFFFF;
    static const uint32_t flagsOffset_=28;
  };

}

#endif