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 "DataFormats/DetId/interface/DetId.h"
#include "Math/GenVector/PositionVector3D.h"

#include "DataFormats/ParticleFlowReco/interface/PFLayer.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. 


namespace reco {

  class PFRecHit {

  public:
    
    enum {
      NONE=0
    };

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

    typedef std::vector<REPPoint> REPPointVector;
 
    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);

    virtual ~PFRecHit();

    void calculatePositionREP();

    //C neighbours must be initialized correctly !!
    /*     void setNeighbours( const std::vector< unsigned >& neighbours ); */
    void add4Neighbour( unsigned index );
    void add8Neighbour( unsigned index );
    void setEnergyUp( double eUp) { energyUp_ = eUp; }
    void setRescale( double factor) { rescale_ = factor; }
    
    void clearNeighbours() {
      neighbours4_.clear();
      neighbours8_.clear();
      neighbours4_.reserve(4);
      neighbours8_.reserve(8);    
    }

    

    // void      findPtrsToNeighbours( const std::map<unsigned,  reco::PFRecHit* >& allhits );

    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 rescale() const { return rescale_; }

    double time() const { return rescale_; }

    double energyUp() const { return energyUp_; }

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

    //C remove cause I want to be able to run on const rechits
    // int  seedState() const { return seedState_; }
    
    // bool isSeed() const { return (seedState_>0) ? true : false; }

    // void youAreSeed(int seedstate=1) {seedState_ = seedstate;} 

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

    const REPPoint& positionREP() const;

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

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

    const REPPointVector& getCornersREP() const 
      { return cornersrep_; }    

    const std::vector< unsigned >& neighbours4() const 
      {return neighbours4_;}  

    const std::vector< unsigned >& neighbours8() const 
      {return neighbours8_;}  

    const std::vector< unsigned >& neighboursIds4() const 
      {return neighboursIds4_;}  

    const std::vector< unsigned >& neighboursIds8() const 
      {return neighboursIds8_;}  

    /*     const std::vector< unsigned >& getNeighboursIds4() const  */
    /*       {return neighboursIds4_;}   */

    /*     const std::vector< unsigned >& getNeighboursIds8() const  */
    /*       {return neighboursIds8_;}   */

    bool  isNeighbour4(unsigned id) const;

    bool  isNeighbour8(unsigned id) const;
    

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

  private:

    unsigned            detId_;             

    PFLayer::Layer                 layer_;

    double              energy_;

    double              rescale_;

    double              energyUp_;

    // int                 seedState_;
 
    math::XYZPoint      position_;

    REPPoint            posrep_;

    math::XYZVector     axisxyz_;

    std::vector< math::XYZPoint > cornersxyz_;
    REPPointVector cornersrep_;
  
    std::vector< unsigned >   neighbours4_;

    std::vector< unsigned >   neighbours8_;

    std::vector< unsigned >   neighboursIds4_;

    std::vector< unsigned >   neighboursIds8_;

    static const unsigned    nNeighbours_;
    
    static const unsigned    nCorners_;

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

#endif