---

Trajectory.h

Go to the documentation of this file.

#ifndef CommonDet_Trajectory_H
#define CommonDet_Trajectory_H

#include "DataFormats/Common/interface/RefToBase.h"
#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h"
#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"


#include <vector>
#include <algorithm>

class Trajectory
{
public:

  typedef std::vector<TrajectoryMeasurement>                   DataContainer;
  typedef TransientTrackingRecHit::ConstRecHitContainer        ConstRecHitContainer;
  typedef ConstRecHitContainer                                 RecHitContainer;


  Trajectory() :  theChiSquared(0), theValid(true),
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(alongMomentum), theDirectionValidity(false),
    theSeed(TrajectorySeed()), seedRef_()  
    {}


  Trajectory( const TrajectorySeed& seed) : 
    theChiSquared(0), theValid(true),
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(alongMomentum), theDirectionValidity(false),
    theSeed(seed), seedRef_()
  {}

  Trajectory( const TrajectorySeed& seed, PropagationDirection dir) : 
    theChiSquared(0), theValid(true),
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(dir), theDirectionValidity(true),
    theSeed(seed), seedRef_()
  {}

  void reserve (unsigned int n) { theData.reserve(n); }
  
  void push( const TrajectoryMeasurement& tm);

  void push( const TrajectoryMeasurement& tm, double chi2Increment);

  void pop();

  TrajectoryMeasurement const & lastMeasurement() const {
    check(); return theData.back();
  }

  TrajectoryMeasurement const & firstMeasurement() const {
    check(); return theData.front();
  }

  DataContainer const & measurements() const { return theData;}
  DataContainer const & data() const { return measurements();}

  ConstRecHitContainer recHits(bool splitting=false) const;

  void recHitsV(ConstRecHitContainer & cont,bool splitting = false) const;

  void validRecHits(ConstRecHitContainer & cont) const;

  int foundHits() const { return theNumberOfFoundHits;}

  int lostHits() const { return theNumberOfLostHits;}
  
  bool empty() const { return theData.empty();}

  double chiSquared() const { return theChiSquared;}

  int ndof(bool bon = true) const;


  PropagationDirection const & direction() const;

  bool isValid() const { return theValid;}

  void invalidate() { theValid = false;}

  TrajectorySeed const & seed() const { return theSeed;}


  static bool inactive(//const Det& det
                       ){return false;}//FIXME

  static bool lost( const TransientTrackingRecHit& hit);

  const DetLayer* lastLayer() const {
    check(); return theData.back().layer();
  }

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

  TrajectoryStateOnSurface geometricalInnermostState() const;

  TrajectoryMeasurement const & closestMeasurement(GlobalPoint) const; 

private:

  struct LessMag {
    LessMag(GlobalPoint point) : thePoint(point) {}
    bool operator()(const TrajectoryMeasurement& lhs,
                    const TrajectoryMeasurement& rhs) const{ 
            return (lhs.updatedState().globalPosition() - thePoint).mag() < (rhs.updatedState().globalPosition() -thePoint).mag();
      }
    GlobalPoint thePoint;
  };

  DataContainer theData;
  double theChiSquared;
  bool theValid;

  int theNumberOfFoundHits;
  int theNumberOfLostHits;

  PropagationDirection theDirection;
  bool                 theDirectionValidity;

  TrajectorySeed       theSeed;
  edm::RefToBase<TrajectorySeed> seedRef_;

  void check() const;
};

#endif

---