PFRecHit.h

Go to the documentation of this file.

#ifndef ParticleFlowReco_PFRecHit_h
#define ParticleFlowReco_PFRecHit_h
 
#include <vector>
#include <map>
#include <memory>
#include <iostream>
 
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "Math/GenVector/PositionVector3D.h"
#include "DataFormats/ParticleFlowReco/interface/PFLayer.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h"
 
#include "DataFormats/CaloRecHit/interface/CaloRecHit.h"
#include "DataFormats/Common/interface/RefToBase.h"
 
#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
 
namespace reco {
 
  class PFRecHit {
  public:
    using PositionType = GlobalPoint::BasicVectorType;
    using REPPoint = RhoEtaPhi;
    using RepCorners = CaloCellGeometry::RepCorners;
    using REPPointVector = RepCorners;
    using CornersVec = CaloCellGeometry::CornersVec;
 
    struct Neighbours {
      using Pointer = unsigned int const*;
      Neighbours() {}
      Neighbours(Pointer ib, unsigned int n) : b(ib), e(ib + n) {}
      Pointer b, e;
      Pointer begin() const { return b; }
      Pointer end() const { return e; }
      unsigned int size() const { return e - b; }
    };
 
    enum { NONE = 0 };
    PFRecHit() {}
 
    PFRecHit(std::shared_ptr<const CaloCellGeometry> caloCell,
             unsigned int detId,
             PFLayer::Layer layer,
             float energy,
             uint32_t flags = 0)
        : caloCell_(std::move(caloCell)), detId_(detId), layer_(layer), energy_(energy), flags_(flags) {}
 
    PFRecHit(const PFRecHit& other) = default;
    PFRecHit(PFRecHit&& other) = default;
    PFRecHit& operator=(const PFRecHit& other) = default;
    PFRecHit& operator=(PFRecHit&& other) = default;
 
    ~PFRecHit() = default;
 
    void setEnergy(float energy) { energy_ = energy; }
 
    void addNeighbour(short x, short y, short z, unsigned int);
    unsigned int getNeighbour(short x, short y, short z) const;
    void setTime(double time) { time_ = time; }
    void setDepth(int depth) { depth_ = depth; }
    void clearNeighbours() {
      neighbours_.clear();
      neighbourInfos_.clear();
      neighbours4_ = neighbours8_ = 0;
    }
 
    Neighbours neighbours4() const { return buildNeighbours(neighbours4_); }
    Neighbours neighbours8() const { return buildNeighbours(neighbours8_); }
 
    Neighbours neighbours() const { return buildNeighbours(neighbours_.size()); }
 
    const std::vector<unsigned short>& neighbourInfos() { return neighbourInfos_; }
 
    CaloCellGeometry const& caloCell() const { return *(caloCell_.get()); }
    bool hasCaloCell() const { return (caloCell_ != nullptr); }
 
    unsigned detId() const { return detId_; }
 
    PFLayer::Layer layer() const { return layer_; }
 
    float energy() const { return energy_; }
 
    float time() const { return time_; }
 
    int depth() const { return depth_; }
 
    double pt2() const { return energy_ * energy_ * (position().perp2() / position().mag2()); }
 
    // Detector-dependent status flag
    uint32_t flags() const { return flags_; }
 
    //
    void setFlags(uint32_t flags) { flags_ = flags; }
 
    PositionType const& position() const { return caloCell().getPosition().basicVector(); }
 
    RhoEtaPhi const& positionREP() const { return caloCell().repPos(); }
 
    CornersVec const& getCornersXYZ() const { return caloCell().getCorners(); }
 
    RepCorners const& getCornersREP() const { return caloCell().getCornersREP(); }
 
    bool operator>=(const PFRecHit& rhs) const { return (energy_ >= rhs.energy_); }
 
    bool operator>(const PFRecHit& rhs) const { return (energy_ > rhs.energy_); }
 
    bool operator<=(const PFRecHit& rhs) const { return (energy_ <= rhs.energy_); }
 
    bool operator<(const PFRecHit& rhs) const { return (energy_ < rhs.energy_); }
 
  private:
    Neighbours buildNeighbours(unsigned int n) const { return Neighbours(neighbours_.data(), n); }
 
    std::shared_ptr<const CaloCellGeometry> caloCell_ = nullptr;
 
    unsigned int detId_ = 0;
 
    PFLayer::Layer layer_ = PFLayer::NONE;
 
    float energy_ = 0;
 
    float time_ = -1;
 
    int depth_ = 0;
 
    std::vector<unsigned int> neighbours_;
    std::vector<unsigned short> neighbourInfos_;
 
    //Caching the neighbours4/8 per request of Lindsey
    unsigned int neighbours4_ = 0;
    unsigned int neighbours8_ = 0;
 
    // Detector-dependent hit status flag
    uint32_t flags_ = 0;
  };
 
}  // namespace reco
std::ostream& operator<<(std::ostream& out, const reco::PFRecHit& hit);
 
#endif