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) : caloCell_(std::move(caloCell)),  detId_(detId),
      layer_(layer), energy_(energy){}


    
    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());}


    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_.front(),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;
  };

}
std::ostream& operator<<(std::ostream& out, const reco::PFRecHit& hit);

#endif