TrackExtra.h

Go to the documentation of this file.

#ifndef TrackReco_TrackExtra_h
#define TrackReco_TrackExtra_h

#include <Rtypes.h>
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Error.h"
#include "DataFormats/TrackReco/interface/TrackExtraBase.h"
#include "DataFormats/TrackReco/interface/TrackResiduals.h"
#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"

namespace reco {
  class TrackExtra : public TrackExtraBase {
  public:
    enum { dimension = 5 };
    enum { covarianceSize = dimension * ( dimension + 1 ) / 2 };
    typedef math::XYZPoint Point;
    typedef math::XYZVector Vector;
    typedef math::Error<5>::type CovarianceMatrix;
    typedef unsigned int index;

    TrackExtra(): 
      outerMomentum_(),
      outerOk_(false),
      outerDetId_(0),
      innerPosition_(),
      innerMomentum_(),
      innerOk_(false),
      innerDetId_(0),
      seedDir_(anyDirection),
      seedRef_(),
      trackResiduals_()
   {
     index idx = 0;
     for( index i = 0; i < dimension; ++ i ) {
       for( index j = 0; j <= i; ++ j ) {
         outerCovariance_[ idx ] = 0;
         innerCovariance_[ idx ] = 0;
         ++idx;
       }
     }
   }

    TrackExtra( const Point & outerPosition, const Vector & outerMomentum, bool ok ,
        const Point & innerPosition, const Vector & innerMomentum, bool iok,
        const CovarianceMatrix& outerState, unsigned int outerId,
        const CovarianceMatrix& innerState, unsigned int innerId, 
        PropagationDirection seedDir, 
        edm::RefToBase<TrajectorySeed>  seedRef=edm::RefToBase<TrajectorySeed>());

    const Point & outerPosition() const { return outerPosition_; }
    const Vector & outerMomentum() const { return outerMomentum_; }
    bool outerOk() const { return outerOk_; }
    const Point & innerPosition() const { return innerPosition_; }
    const Vector & innerMomentum() const { return innerMomentum_; }
    bool innerOk() const { return innerOk_; }
    double outerPx() const { return outerMomentum_.X(); }
    double outerPy() const { return outerMomentum_.Y(); }
    double outerPz() const { return outerMomentum_.Z(); }
    double outerX() const { return outerPosition_.X(); }
    double outerY() const { return outerPosition_.Y(); }
    double outerZ() const { return outerPosition_.Z(); }
    double outerP() const { return outerMomentum().R(); }
    double outerPt() const { return outerMomentum().Rho(); }
    double outerPhi() const { return outerMomentum().Phi(); }
    double outerEta() const { return outerMomentum().Eta(); }
    double outerTheta() const { return outerMomentum().Theta(); }
    double outerRadius() const { return outerPosition().Rho(); }

    CovarianceMatrix outerStateCovariance() const;
    CovarianceMatrix innerStateCovariance() const;
    CovarianceMatrix & fillOuter( CovarianceMatrix & v ) const;
    CovarianceMatrix & fillInner( CovarianceMatrix & v ) const;
    unsigned int outerDetId() const { return outerDetId_; }
    unsigned int innerDetId() const { return innerDetId_; }
    // direction how the hits were sorted in the original seed
    PropagationDirection seedDirection() const {return seedDir_;}

    edm::RefToBase<TrajectorySeed> seedRef() const { return seedRef_; }
    void setSeedRef( edm::RefToBase<TrajectorySeed> & r) { seedRef_=r; }
    void setResiduals (const TrackResiduals &r) { trackResiduals_ = r; }

    const TrackResiduals &residuals () const { return trackResiduals_; }

  private:

    Point outerPosition_;
    Vector outerMomentum_;
    bool outerOk_;
    float outerCovariance_[ covarianceSize ];
    unsigned int outerDetId_;


    Point innerPosition_;
    Vector innerMomentum_;
    bool innerOk_;
    float innerCovariance_[ covarianceSize ];
    unsigned int innerDetId_;

    PropagationDirection seedDir_;
    edm::RefToBase<TrajectorySeed> seedRef_;

    TrackResiduals trackResiduals_;
  };

}

#endif