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/TrackReco/interface/TrajectoryStopReasons.h"
#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

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

class Trajectory
{
public:

  typedef std::vector<TrajectoryMeasurement>                   DataContainer;
  using ConstRecHitContainer = TrackingRecHit::ConstRecHitContainer;
  using RecHitContainer = ConstRecHitContainer;

  Trajectory() {}


  explicit Trajectory( const TrajectorySeed& seed) : 
    theSeed( new TrajectorySeed(seed) ),
    theValid(true)
  {}

  Trajectory( const TrajectorySeed& seed, PropagationDirection dir) : 
    theSeed( new TrajectorySeed(seed) ),
    theDirection(dir),
    theDirectionValidity(true),
    theValid(true)
  {}

  Trajectory( const boost::shared_ptr<const TrajectorySeed> & seed, PropagationDirection dir) : 
    theSeed( seed ),
    theDirection(dir),
    theDirectionValidity(true),
    theValid(true)
  {}

  explicit Trajectory(PropagationDirection dir) : 
    theDirection(dir),
    theDirectionValidity(true),
    theValid(true)
  {}


  Trajectory(Trajectory const & rh) = default;
  Trajectory & operator=(Trajectory const & rh) = default;

  Trajectory(Trajectory && rh) : 
    theSeed(std::move(rh.theSeed)),
    seedRef_(std::move(rh.seedRef_)),
    theData(std::move(rh.theData)),
    theChiSquared(rh.theChiSquared),
    theChiSquaredBad(rh.theChiSquaredBad),
    theNumberOfFoundHits(rh.theNumberOfFoundHits),
    theNumberOfFoundPixelHits(rh.theNumberOfFoundPixelHits),
    theNumberOfLostHits(rh.theNumberOfLostHits),
    theNumberOfTrailingFoundHits(rh.theNumberOfTrailingFoundHits),
    theNumberOfCCCBadHits_(rh.theNumberOfCCCBadHits_),
    theDirection(rh.theDirection),
    theDirectionValidity(rh.theDirectionValidity),
    theValid(rh.theValid),
    theDPhiCache(rh.theDPhiCache),
    theCCCThreshold_(rh.theCCCThreshold_),
    theNLoops(rh.theNLoops),
    stopReason_(rh.stopReason_)
  {}

  Trajectory & operator=(Trajectory && rh) {
    using std::swap;
    swap(theData,rh.theData);
    theChiSquared=rh.theChiSquared;
    theChiSquaredBad=rh.theChiSquaredBad;
    theValid=rh.theValid;
    theDPhiCache=rh.theDPhiCache;
    theCCCThreshold_=rh.theCCCThreshold_;
    theNLoops=rh.theNLoops;  
    theNumberOfFoundHits=rh.theNumberOfFoundHits;
    theNumberOfFoundPixelHits=rh.theNumberOfFoundPixelHits;
    theNumberOfLostHits=rh.theNumberOfLostHits;
    theNumberOfTrailingFoundHits=rh.theNumberOfTrailingFoundHits;
    theNumberOfCCCBadHits_=rh.theNumberOfCCCBadHits_;
    theDirection=rh.theDirection; 
    theDirectionValidity=rh.theDirectionValidity;
    stopReason_ = rh.stopReason_;
    swap(theSeed,rh.theSeed);
    swap(seedRef_,rh.seedRef_);

    return *this;

  }


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

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

  void pop();

  TrajectoryMeasurement const & lastMeasurement() const {
    check(); 
    if (theData.back().recHitR().hit()!=nullptr) 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().recHitR().hit()!=nullptr) 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 & measurements() { return theData;}

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

  ConstRecHitContainer recHits() const {
    ConstRecHitContainer hits;
    hits.reserve(theData.size());
    for (Trajectory::DataContainer::const_iterator itm
           = theData.begin(); itm != theData.end(); itm++){
      hits.push_back((*itm).recHit());
    }
    return hits;
  }

  void validRecHits(ConstRecHitContainer & cont) const;

  int foundHits() const { return theNumberOfFoundHits;}

  int foundPixelHits() const { return theNumberOfFoundPixelHits;}

  int lostHits() const { return theNumberOfLostHits;}

   int trailingFoundHits() const { return theNumberOfTrailingFoundHits;}


  int cccBadHits() const { return theNumberOfCCCBadHits_;}

  //number of hits in seed
  unsigned int seedNHits() const { return seed().nHits();}

  
  bool empty() const { return theData.empty();}

  float 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 TrackingRecHit& hit);

  static bool isBad( const TrackingRecHit& hit);

  static bool pixel( const TrackingRecHit& hit);

  const DetLayer* lastLayer() const {
    check();
    if (theData.back().recHit()->hit()!=nullptr) 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; }
  void setSharedSeed(const boost::shared_ptr<const TrajectorySeed> & seed) { theSeed=seed;}

   float dPhiCacheForLoopersReconstruction() const { return theDPhiCache;}

   float cccThreshold() const {return theCCCThreshold_;}

   void setDPhiCacheForLoopersReconstruction(float dphi) {  theDPhiCache = dphi;}

   bool isLooper() const { return (theNLoops>0);}
   signed char nLoops() const {return theNLoops;}

   void setNLoops(signed char value) { theNLoops=value;}
   void incrementLoops() {theNLoops++;}

   void setStopReason(StopReason s) { stopReason_ = s; }
   StopReason stopReason() const {return stopReason_;}

   int numberOfCCCBadHits(float ccc_threshold);

private:

  void pushAux(double chi2Increment);
  bool badForCCC(const TrajectoryMeasurement &tm);
  void updateBadForCCC(float ccc_threshold);

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

  DataContainer theData;
  float theChiSquared=0;
  float theChiSquaredBad=0;

  signed short theNumberOfFoundHits=0;
  signed short theNumberOfFoundPixelHits=0;
  signed short theNumberOfLostHits=0;
  signed short theNumberOfTrailingFoundHits=0;
  signed short theNumberOfCCCBadHits_=0;

  PropagationDirection theDirection=anyDirection;
  bool                 theDirectionValidity=false;
  bool theValid=false;

  float theDPhiCache=0;
  float theCCCThreshold_=std::numeric_limits<float>::max();
  signed char theNLoops=0;
  StopReason stopReason_ = StopReason::UNINITIALIZED;

  void check() const;
};

#endif