Vertex.h

Go to the documentation of this file.

#ifndef VertexReco_Vertex_h
#define VertexReco_Vertex_h

#include <Rtypes.h>
#include "DataFormats/Math/interface/Error.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/Common/interface/RefToBase.h" 
#include <Math/GenVector/PxPyPzE4D.h>                                                                                                   
#include <Math/GenVector/PxPyPzM4D.h> 
#include "DataFormats/Math/interface/LorentzVector.h"                                                                                   

namespace reco {

  class Track;

  class Vertex {
  public:
    typedef std::vector<TrackBaseRef >::const_iterator trackRef_iterator;
    typedef math::XYZPoint Point;
    enum { dimension = 3, dimension4D = 4 };
    typedef math::Error<dimension>::type Error;
    typedef math::Error<dimension>::type CovarianceMatrix;
    typedef math::Error<dimension4D>::type Error4D;
    typedef math::Error<dimension4D>::type CovarianceMatrix4D;    
    enum { size = dimension * ( dimension + 1 ) / 2, size4D = ( dimension4D ) * ( dimension4D + 1 ) / 2 };    
    typedef unsigned int index;
    Vertex():  chi2_( 0.0 ), ndof_( 0 ), position_(0.,0.,0.), time_(0.) { validity_ = false; for(int i = 0; i < size4D; ++ i ) covariance_[i]=0.;
}
    Vertex( const Point &, const Error &);
    Vertex( const Point &, const Error4D &, double);
    Vertex( const Point &, const Error &, double chi2, double ndof, size_t size );
    Vertex( const Point &, const Error4D &, double time, double chi2, double ndof, size_t size );
    bool isValid() const {return validity_;}
    bool isFake() const {return (chi2_==0 && ndof_==0 && tracks_.empty());}
    void add( const TrackBaseRef & r, float w=1.0 );
    void add( const TrackBaseRef & r, const Track & refTrack, float w=1.0 );
    void removeTracks();

    template<typename TREF> 
    float trackWeight ( const TREF & r ) const {
      int i=0;
      for(auto const & t : tracks_) {
        if ( (r.id()==t.id()) & (t.key()==r.key()) ) return weights_[i]/255.f;
        ++i;
      }
      return 0;
    }
    trackRef_iterator tracks_begin() const;
    trackRef_iterator tracks_end() const;
    size_t tracksSize() const;
    const TrackBaseRef& trackRefAt(size_t idx) const { return tracks_[idx]; }
    double chi2() const { return chi2_; }
    double ndof() const { return ndof_; }
    double normalizedChi2() const { return ndof_ != 0 ? chi2_ / ndof_ : chi2_ * 1e6; }
    const Point & position() const { return position_; }
    double x() const { return position_.X(); }
    double y() const { return position_.Y(); }
    double z() const { return position_.Z(); }
    double t() const { return time_; } 
    double xError() const { return sqrt( covariance(0, 0) ); }
    double yError() const { return sqrt( covariance(1, 1) ); }
    double zError() const { return sqrt( covariance(2, 2) ); }
    double tError() const { return sqrt( covariance(3, 3) ); }
    // Note that:
    //   double error( int i, int j ) const 
    // is OBSOLETE, use covariance(i, j)
    double covariance( int i, int j ) const { 
      return covariance_[ idx( i, j ) ]; 
    }
    CovarianceMatrix covariance() const { Error m; fill( m ); return m; }
    CovarianceMatrix4D covariance4D() const { Error4D m; fill( m ); return m; }

    Error error() const { Error m; fill( m ); return m; }
    Error4D error4D() const { Error4D m; fill( m ); return m; }
    
    void fill( CovarianceMatrix & v ) const;
    void fill( CovarianceMatrix4D & v ) const;

    bool hasRefittedTracks() const {return !refittedTracks_.empty();}
    
    TrackBaseRef originalTrack(const Track & refTrack) const;

    Track refittedTrack(const TrackBaseRef & track) const;

    Track refittedTrack(const TrackRef & track) const;

    const std::vector<Track> & refittedTracks() const { return refittedTracks_;}

    math::XYZTLorentzVectorD p4(float mass=0.13957018,float minWeight=0.5) const; 

    unsigned int nTracks(float minWeight=0.5) const; 

    class TrackEqual {
      public:
    TrackEqual( const Track & t) : track_( t ) { }
    bool operator()( const Track & t ) const { return t.pt()==track_.pt();}
      private:
    const Track & track_;
    };

  private:
    float chi2_;
    float ndof_;
    Point position_;
    float covariance_[size4D];
    std::vector<TrackBaseRef> tracks_;
    std::vector<Track> refittedTracks_;
    std::vector<uint8_t> weights_;
    bool validity_;
    double time_;

    index idx( index i, index j ) const {
      int a = ( i <= j ? i : j ), b = ( i <= j ? j : i );
      return b * ( b + 1 ) / 2 + a;
    }
  };
  
}

#endif