Vertexing.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_interface_Vertexing_h
#define DataFormats_PatCandidates_interface_Vertexing_h

#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/Common/interface/Ptr.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1DFloat.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"

namespace pat {
    class VertexAssociation {
        public:
            VertexAssociation() {}
            VertexAssociation(const reco::VertexRef &vertex) : vertex_(vertex) {}
            VertexAssociation(const reco::VertexRef &vertex, const reco::TrackBaseRef &tk) : vertex_(vertex), track_(tk) {}
            // --- Methods to mimick VertexRef
            bool  isNull() const      { return vertex_.isNull(); }
            bool  isNonnull() const   { return vertex_.isNonnull(); }
            bool  isAvailable() const { return vertex_.isAvailable(); }
            const reco::Vertex & operator*()  const { return * operator->(); }
            const reco::Vertex * operator->() const { return vertex_.isNull() ? 0 : vertex_.get(); }
            // --- Methods to get the Vertex and track
            const reco::VertexRef & vertexRef() const  { return vertex_; }
            const reco::Vertex    * vertex()    const  { return vertex_.isNull() ? 0 : vertex_.get(); }
            bool                       hasTrack() const { return !track_.isNull(); }
            const reco::TrackBaseRef & trackRef() const { return track_; }
            const reco::Track        * track()    const { return hasTrack() ? track_.get() : 0; }
            // --- Methods to return distances
            const Measurement1DFloat & dz() const { return dz_; }
            const Measurement1DFloat & dr() const { return dr_; }
            bool  hasTransverseIP() const { return (dr_.value() != 0); }
            bool  hasErrors()       const { return (dz_.error() != 0) && ( !hasTransverseIP() || dr_.error() != 0 ); }
            // ---- Methods to set distances 
            void setDz(const Measurement1DFloat & dz) { dz_ = dz; }
            void setDr(const Measurement1DFloat & dr) { dr_ = dr; }
            void setDz(const Measurement1D & dz)      { dz_ = Measurement1DFloat(dz.value(), dz.error()); }
            void setDr(const Measurement1D & dr)      { dr_ = Measurement1DFloat(dr.value(), dr.error()); }
            void setDistances(const AlgebraicVector3 & dist, const AlgebraicSymMatrix33 &err) ;
            template<typename T1, typename T2>
            void setDistances(const T1 & p1, const T2 &p2, const AlgebraicSymMatrix33 &err) {
                AlgebraicVector3 dist(p1.x() - p2.x(), p1.y() - p2.y(), p1.z() - p2.z());
                setDistances(dist, err);
            }
            // ---- 3D significance of the impact parameter
            // float signif3d()           const { return signif3d_; }
            // bool  hasSignif3d()        const { return signif3d_ != 0; }
            // void setSignif3d(float signif3d) { signif3d_ = signif3d; }
        private:
            // basic information
            reco::VertexRef vertex_;
            Measurement1DFloat dz_, dr_;
            // float signif3d_;
            // extended info
            reco::TrackBaseRef track_;
            // fixme: add refitted momentum
    };
}

#endif