/data/refman/pasoursint/CMSSW_6_1_2_SLHC2/src/TrackingTools/PatternTools/interface/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() : 
    theSeed(), seedRef_(),
    theChiSquared(0), theChiSquaredBad(0),
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(anyDirection), theDirectionValidity(false), theValid(false),theDPhiCache(0),theNLoops(0)
    {}


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

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

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

  explicit Trajectory(PropagationDirection dir) : 
    theSeed(), seedRef_(),
    theChiSquared(0), theChiSquaredBad(0),
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(dir), theDirectionValidity(true), theValid(true),theDPhiCache(0),theNLoops(0)
   
  {}


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


  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), theNumberOfLostHits(rh.theNumberOfLostHits),
    theDirection(rh.theDirection), theDirectionValidity(rh.theDirectionValidity), theValid(rh.theValid),
    theDPhiCache(rh.theDPhiCache),theNLoops(rh.theNLoops)  
  {}

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

    return *this;

  }

 Trajectory & operator=(Trajectory const & rh) {
    theData = rh.theData;
    theChiSquared=rh.theChiSquared;
    theChiSquaredBad=rh.theChiSquaredBad;
    theValid=rh.theValid;
    theDPhiCache=rh.theDPhiCache; 
    theNLoops=rh.theNLoops;  
    theNumberOfFoundHits=rh.theNumberOfFoundHits;
    theNumberOfLostHits=rh.theNumberOfLostHits;
    theDirection=rh.theDirection;
    theDirectionValidity=rh.theDirectionValidity;
    theSeed = rh.theSeed;
    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().recHitR().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().recHitR().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; }
  void setSharedSeed(const boost::shared_ptr<const TrajectorySeed> & seed) { theSeed=seed;}

   float dPhiCacheForLoopersReconstruction() const { return theDPhiCache;}

   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++;}

private:

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

  DataContainer theData;
  float theChiSquared;
  float theChiSquaredBad;

  signed short theNumberOfFoundHits;
  signed short theNumberOfLostHits;

  PropagationDirection theDirection;
  bool                 theDirectionValidity;
  bool theValid;

  float theDPhiCache;
  signed char theNLoops;

  void check() const;
};

#endif