TempTrajectory.h

Go to the documentation of this file.

#ifndef CkfPattern_TempTrajectory_H
#define CkfPattern_TempTrajectory_H

#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h"
#include "DataFormats/TrackReco/interface/TrajectoryStopReasons.h"
#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
#include "DataFormats/Common/interface/OwnVector.h"

#include <vector>
#include <algorithm>
#include <limits>
#include "TrackingTools/PatternTools/interface/bqueue.h"

#include "TrackingTools/PatternTools/interface/Trajectory.h"
#include "FWCore/Utilities/interface/GCC11Compatibility.h"

class TempTrajectory
{
public:

  typedef cmsutils::bqueue<TrajectoryMeasurement>              DataContainer;
  typedef TrackingRecHit::ConstRecHitContainer                 ConstRecHitContainer;
  typedef ConstRecHitContainer                                 RecHitContainer;


  TempTrajectory() {}
  
  
 
  TempTrajectory(PropagationDirection dir, unsigned char nhseed) : 
  theDirection(dir),
  theValid(true),
  theNHseed(nhseed)
  {}

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

  TempTrajectory(TempTrajectory && rh) noexcept :
    theData(std::move(rh.theData)),
    theChiSquared(rh.theChiSquared), 
    theNumberOfFoundHits(rh.theNumberOfFoundHits),
    theNumberOfFoundPixelHits(rh.theNumberOfFoundPixelHits),
    theNumberOfLostHits(rh.theNumberOfLostHits),
    theNumberOfTrailingFoundHits(rh.theNumberOfTrailingFoundHits),
    theNumberOfCCCBadHits_(rh.theNumberOfCCCBadHits_),
    theDirection(rh.theDirection),
    theValid(rh.theValid),
    theNHseed(rh.theNHseed),
    theNLoops(rh.theNLoops),
    theDPhiCache(rh.theDPhiCache),
    theCCCThreshold_(rh.theCCCThreshold_),
    stopReason_(rh.stopReason_){}

  TempTrajectory & operator=(TempTrajectory && rh) noexcept {
    using std::swap;
    swap(theData,rh.theData);
    theChiSquared=rh.theChiSquared;
    theNumberOfFoundHits=rh.theNumberOfFoundHits;
    theNumberOfFoundPixelHits=rh.theNumberOfFoundPixelHits;
    theNumberOfLostHits=rh.theNumberOfLostHits;
    theNumberOfTrailingFoundHits=rh.theNumberOfTrailingFoundHits;
    theNumberOfCCCBadHits_=rh.theNumberOfCCCBadHits_;
    theDirection=rh.theDirection;
    theValid=rh.theValid;    
    theNHseed=rh.theNHseed;
    theNLoops=rh.theNLoops;
    theDPhiCache=rh.theDPhiCache;
    theCCCThreshold_=rh.theCCCThreshold_;
    stopReason_=rh.stopReason_;
    return *this;

  }


  explicit TempTrajectory(Trajectory && traj);


  ~TempTrajectory() {}

  void push( const TrajectoryMeasurement& tm){
    push( tm, tm.estimate());
  }

  void push(TrajectoryMeasurement&& tm){
    push( std::forward<TrajectoryMeasurement>(tm), tm.estimate());
  }

  template<typename... Args>
  void emplace(Args && ...args) {
    theData.emplace_back(std::forward<Args>(args)...);
    pushAux(theData.back().estimate());
  }

  void push(TempTrajectory const & segment);

      

  void join( TempTrajectory & segment);



  void push( const TrajectoryMeasurement& tm, double chi2Increment) {
      theData.push_back(tm);
      pushAux(chi2Increment);
  }

  void push( TrajectoryMeasurement&& tm, double chi2Increment) {
    theData.push_back(std::move(tm));
    pushAux(chi2Increment);
  }

  
  template<typename... Args>
  void emplace(double chi2Increment, Args && ...args) { // works only because the first Arg is never a double!
    theData.emplace_back(std::forward<Args>(args)...);
    pushAux(chi2Increment);
  }


  void pop();

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

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

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


  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 theNHseed;}
  
  bool empty() const { return theData.empty();}

  float chiSquared() const { return theChiSquared;}

  PropagationDirection direction() const;

  bool isValid() const { return theValid;}

  void invalidate() { theValid = false;}


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


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

  Trajectory toTrajectory() const;

  void popInvalidTail() ;


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

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

   int numberOfCCCBadHits(float ccc_threshold);

  static bool lost( const TrackingRecHit& hit) dso_internal;

private:
  bool badForCCC(const TrajectoryMeasurement &tm) dso_internal;
  void updateBadForCCC(float ccc_threshold) dso_internal;



  void pushAux(double chi2Increment);

private:

  DataContainer theData;

  float theChiSquared=0;

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

  // PropagationDirection 
  signed char theDirection=anyDirection;
  bool theValid=false;
 
  unsigned char theNHseed=0;

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

  void check() const;
};

#endif