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