PFRecHit.h

Go to the documentation of this file.

#ifndef ParticleFlowReco_PFRecHit_h
#define ParticleFlowReco_PFRecHit_h

#include <vector>
#include <map>
#include <iostream>

#include "DataFormats/Math/interface/Point3D.h"
#include "Rtypes.h" 
#include "DataFormats/Math/interface/Vector3D.h"
#include "Math/GenVector/PositionVector3D.h"
#include "DataFormats/ParticleFlowReco/interface/PFLayer.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h"

//C decide what is the default rechit index. 
//C maybe 0 ? -> compression 
//C then the position is index-1. 
//C provide a helper class to access the rechit. 

#include "DataFormats/CaloRecHit/interface/CaloRecHit.h"
#include "DataFormats/Common/interface/RefToBase.h"


namespace reco {

  class PFRecHit {

  public:

    // Next typedef uses double in ROOT 6 rather than Double32_t due to a bug in ROOT 5,
    // which otherwise would make ROOT5 files unreadable in ROOT6.  This does not increase
    // the size on disk, because due to the bug, double was actually stored on disk in ROOT 5.

    typedef ROOT::Math::PositionVector3D<ROOT::Math::CylindricalEta3D<double> > REPPoint;

    typedef std::vector<REPPoint> REPPointVector;

    enum {
      NONE=0
    };
    PFRecHit();

    PFRecHit(unsigned detId,
             PFLayer::Layer layer,
             double energy, 
             const math::XYZPoint& posxyz, 
             const math::XYZVector& axisxyz, 
             const std::vector< math::XYZPoint >& cornersxyz);

    PFRecHit(unsigned detId,
             PFLayer::Layer layer,
             double energy, 
             double posx, double posy, double posz, 
             double axisx, double axisy, double axisz);    

    PFRecHit(const PFRecHit& other) = default;
    PFRecHit(PFRecHit&& other) = default;
    PFRecHit & operator=(const PFRecHit& other) = default;
    PFRecHit & operator=(PFRecHit&& other) = default;


    ~PFRecHit()=default;

    void setEnergy( double energy) { energy_ = energy; }

    void calculatePositionREP();

    void addNeighbour(short x,short y, short z,const PFRecHitRef&);
    const PFRecHitRef getNeighbour(short x,short y, short z);
    void setTime( double time) { time_ = time; }
    void setDepth( int depth) { depth_ = depth; }
    void clearNeighbours() {
      neighbours_.clear();
    }

    const PFRecHitRefVector& neighbours4() const {
      return neighbours4_;
    }
    const PFRecHitRefVector& neighbours8() const {
      return neighbours8_;
    }

    const PFRecHitRefVector& neighbours() const {
      return neighbours_;
    }

    const std::vector<unsigned short>& neighbourInfos() {
      return neighbourInfos_;
    }


    void      setNWCorner( double posx, double posy, double posz );
    void      setSWCorner( double posx, double posy, double posz );
    void      setSECorner( double posx, double posy, double posz );
    void      setNECorner( double posx, double posy, double posz );

    unsigned detId() const {return detId_;}

    PFLayer::Layer layer() const { return layer_; }

    double energy() const { return energy_; }


    double time() const { return time_; }

    int  depth() const { return depth_; }

    double pt2() const { return energy_ * energy_ *
               ( position_.X()*position_.X() + 
                 position_.Y()*position_.Y() ) / 
               ( position_.X()*position_.X() +
                 position_.Y()*position_.Y() + 
                 position_.Z()*position_.Z()) ; }


    const math::XYZPoint& position() const { return position_; }

    const REPPoint& positionREP() const { return positionrep_; }


    const math::XYZVector& getAxisXYZ() const { return axisxyz_; }    

    const std::vector< math::XYZPoint >& getCornersXYZ() const 
      { return cornersxyz_; }    

    const std::vector<REPPoint>& getCornersREP() const { return cornersrep_; }

    void size(double& deta, double& dphi) const;

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

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

    const edm::RefToBase<CaloRecHit>& originalRecHit() const {
      return originalRecHit_;
    }

    template<typename T> 
    void setOriginalRecHit(const T& rh) {
      originalRecHit_ = edm::RefToBase<CaloRecHit>(rh);
    }

  private:

    // original rechit
    edm::RefToBase<CaloRecHit> originalRecHit_;

    unsigned            detId_;             

    PFLayer::Layer      layer_;

    double              energy_;

    double              time_;


    int      depth_;

    math::XYZPoint      position_;

    REPPoint positionrep_;

    math::XYZVector     axisxyz_;

    std::vector< math::XYZPoint > cornersxyz_;

    std::vector< REPPoint > cornersrep_;
  
    PFRecHitRefVector   neighbours_;
    std::vector< unsigned short >   neighbourInfos_;

    //Caching the neighbours4/8 per request of Lindsey
    PFRecHitRefVector   neighbours4_;
    PFRecHitRefVector   neighbours8_;


    static const unsigned    nCorners_;

    void      setCorner( unsigned i, double posx, double posy, double posz );
  };
  
}

#endif