/data/refman/pasoursint/CMSSW_5_2_9/src/TrackingTools/TransientTrack/interface/TransientTrack.h

Go to the documentation of this file.

#ifndef TrackReco_TransientTrack_h
#define TrackReco_TransientTrack_h


#include "TrackingTools/TransientTrack/interface/BasicTransientTrack.h"
#include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h" 

#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h" 
#include "DataFormats/Common/interface/RefToBase.h" 

namespace reco {

  class TransientTrack : private  BasicTransientTrack::Proxy {

    typedef BasicTransientTrack::Proxy             Base;

  public:

    TransientTrack() {}

    explicit TransientTrack( BasicTransientTrack * btt ) : Base(btt) {}

    ~TransientTrack() {}


#if defined( __GXX_EXPERIMENTAL_CXX0X__)

    TransientTrack(TransientTrack const & rh) :
      Base(rh){}
    
    
    TransientTrack(TransientTrack && rh) :
      Base(std::move(rh)){}
    
    TransientTrack & operator=(TransientTrack && rh) {
      this->Base::operator=(std::move(rh));
      //      Base::swap(rh);
      return *this;
    }
    
    TransientTrack & operator=(TransientTrack const & rh) {
      this->Base::operator=(rh);
      return *this;
    }
    
    
#else
    
    void swap(TransientTrack & rh) {
      Base::swap(rh);
    }
#endif

    TransientTrack( const Track & tk , const MagneticField* field); 
    TransientTrack( const TrackRef & tk , const MagneticField* field); 

    TransientTrack( const TrackRef & tk , const MagneticField* field, const edm::ESHandle<GlobalTrackingGeometry>& trackingGeometry);

    TransientTrack( const Track & tk , const MagneticField* field, const edm::ESHandle<GlobalTrackingGeometry>& trackingGeometry);



    void setES(const edm::EventSetup& es) {sharedData().setES(es);}

    void setTrackingGeometry(const edm::ESHandle<GlobalTrackingGeometry>& tg)
        {sharedData().setTrackingGeometry(tg);}

    void setBeamSpot(const reco::BeamSpot& beamSpot) 
        {sharedData().setBeamSpot(beamSpot);}

    FreeTrajectoryState initialFreeState() const {return data().initialFreeState();}

    TrajectoryStateOnSurface outermostMeasurementState() const
        {return data().outermostMeasurementState();}

    TrajectoryStateOnSurface innermostMeasurementState() const
        {return data().innermostMeasurementState();}

    TrajectoryStateClosestToPoint 
      trajectoryStateClosestToPoint( const GlobalPoint & point ) const
        {return data().trajectoryStateClosestToPoint(point);}

    TrajectoryStateOnSurface stateOnSurface(const GlobalPoint & point) const
        {return data().stateOnSurface(point);}

    TrajectoryStateClosestToPoint impactPointTSCP() const
        {return data().impactPointTSCP();}

    TrajectoryStateOnSurface impactPointState() const
        {return data().impactPointState();}

    bool impactPointStateAvailable() const
        {return data().impactPointStateAvailable();}

    TrackCharge charge() const {return data().charge();}

    bool operator== (const TransientTrack & other) const
        {return &(data()) == &(other.data());}
    // {return (a.persistentTrackRef()==tkr_);}

    bool operator< (const TransientTrack & other) const 
        {return &(data()) < &(other.data());}
    // {return (initialFTS.momentum().z()<a.initialFreeState().momentum().z());}

    const MagneticField* field() const {return data().field();}

    const BasicTransientTrack* basicTransientTrack() const {return &(data());}

    const Track & track() const {return data().track();}

    TrackBaseRef trackBaseRef() const {return data().trackBaseRef();}

    TrajectoryStateClosestToBeamLine stateAtBeamLine() const
        {return data().stateAtBeamLine();}

// Methods forwarded to original track.

    trackingRecHit_iterator recHitsBegin() const { return track().recHitsBegin(); }
    trackingRecHit_iterator recHitsEnd() const { return track().recHitsEnd(); }
    TrackingRecHitRef recHit( size_t i ) const { return track().recHit( i ); }
    size_t recHitsSize() const { return track().recHitsSize(); }
    //  hit pattern
    const HitPattern & hitPattern() const { return track().hitPattern(); }
    unsigned short numberOfValidHits() const { return track().hitPattern().numberOfValidHits(); }
    unsigned short numberOfLostHits() const { return track().hitPattern().numberOfLostHits(); }
    double chi2() const { return track().chi2(); }
    double ndof() const { return track().ndof(); }
    double normalizedChi2() const { return track().chi2() / track().ndof(); }

    bool isValid() const {return Base::isValid() ;}

  };

}

#endif