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;
  std::ostream& operator<<(std::ostream& out, const CaloCluster& cluster);
 
  class CaloCluster {
  public:
    enum AlgoId {
      island = 0,
      hybrid = 1,
      fixedMatrix = 2,
      dynamicHybrid = 3,
      multi5x5 = 4,
      particleFlow = 5,
      hgcal_em = 6,
      hgcal_had = 7,
      hgcal_mixed = 8,
      hfnose = 9,
      undefined = 1000
    };
 
    // super-cluster flags
    enum SCFlags { cleanOnly = 0, common = 100, uncleanOnly = 200 };
    // hcal cluster flags (used for pf)
    enum HCalFlags { badHcalMarker = 1 };
 
    //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),
          correctedEnergyUncertainty_(-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),
          correctedEnergyUncertainty_(-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),
          correctedEnergyUncertainty_(-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),
          correctedEnergyUncertainty_(-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;
  };
 
}  // namespace reco
 
#endif