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 "FWCore/MessageLogger/interface/MessageLogger.h"

#include <vector>
#include <algorithm>
#include <boost/shared_ptr.hpp>

class Trajectory
{
public:

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


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


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

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

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


#if defined( __GXX_EXPERIMENTAL_CXX0X__)
  Trajectory(Trajectory && rh) : 
    theData(std::move(rh.theData)),
    theChiSquared(rh.theChiSquared), theChiSquaredBad(rh.theChiSquaredBad), theValid(rh.theValid),
    theNumberOfFoundHits(rh.theNumberOfFoundHits), theNumberOfLostHits(rh.theNumberOfLostHits),
    theDirection(rh.theDirection), theDirectionValidity(rh.theDirectionValidity),
    theSeed(std::move(rh.theSeed)), seedRef_(std::move(rh.seedRef_))
  {}

  Trajectory & operator=(Trajectory && rh) {
    using std::swap;
    swap(theData,rh.theData);
    theChiSquared=rh.theChiSquared;
    theChiSquaredBad=rh.theChiSquaredBad;
    theValid=rh.theValid;
    theNumberOfFoundHits=rh.theNumberOfFoundHits;
    theNumberOfLostHits=rh.theNumberOfLostHits;
    theDirection=rh.theDirection; 
    theDirectionValidity=rh.theDirectionValidity;
    swap(theSeed,rh.theSeed);
    swap(seedRef_,rh.seedRef_);

    return *this;

  }

#endif

  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(); 
    if (theData.back().recHit()->hit()!=0) return theData.back();
    else if (theData.size()>2) return *(theData.end()-2);
    else throw cms::Exception("TrajectoryMeasurement::lastMeasurement - Too few measurements in trajectory");
  }

  TrajectoryMeasurement const & firstMeasurement() const {
    check(); 
    if (theData.front().recHit()->hit()!=0) return theData.front();
    else if (theData.size()>2) return *(theData.begin()+1);
    else throw cms::Exception("TrajectoryMeasurement::firstMeasurement - Too few measurements in trajectory");
  }
  
  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 (theNumberOfFoundHits ? theChiSquared : theChiSquaredBad);}

  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);

  static bool isBad( const TransientTrackingRecHit& hit);

  const DetLayer* lastLayer() const {
    check();
    if (theData.back().recHit()->hit()!=0) return theData.back().layer();
    else if (theData.size()>2) return (theData.end()-2)->layer();
    else throw cms::Exception("TrajectoryMeasurement::lastMeasurement - Too few measurements in trajectory");
  }

  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; 

  void reverse() ;

  const boost::shared_ptr<const TrajectorySeed> & sharedSeed() const { return theSeed; }
private:


  DataContainer theData;
  double theChiSquared;
  double theChiSquaredBad;
  bool theValid;

  int theNumberOfFoundHits;
  int theNumberOfLostHits;

  PropagationDirection theDirection;
  bool                 theDirectionValidity;

  boost::shared_ptr<const TrajectorySeed>    theSeed;
  edm::RefToBase<TrajectorySeed> seedRef_;

  void check() const;
};

#endif