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/TrajectorySeed/interface/PropagationDirection.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
#include "DataFormats/Common/interface/OwnVector.h"

#include <vector>
#include <algorithm>
#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() : 
    theChiSquared(0),
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(anyDirection), theDirectionValidity(false), 
    theValid(false),theNLoops(0),theDPhiCache(0)
  {}
  
  
 
  explicit TempTrajectory(PropagationDirection dir) : 
  theChiSquared(0), 
  theNumberOfFoundHits(0), theNumberOfLostHits(0),
  theDirection(dir), theDirectionValidity(true),
  theValid(true),theNLoops(0),theDPhiCache(0)
  {}

  
  
  TempTrajectory(TempTrajectory const & rh) : 
    theData(rh.theData),
    theChiSquared(rh.theChiSquared), 
    theNumberOfFoundHits(rh.theNumberOfFoundHits), theNumberOfLostHits(rh.theNumberOfLostHits),
    theDirection(rh.theDirection), theDirectionValidity(rh.theDirectionValidity),theValid(rh.theValid)
    ,theNLoops(rh.theNLoops)
    ,theDPhiCache(rh.theDPhiCache)
  {}
  
  
  TempTrajectory & operator=(TempTrajectory const & rh) {
    DataContainer aData(rh.theData);
    using std::swap;
    swap(theData,aData);
    theChiSquared=rh.theChiSquared;
    theNumberOfFoundHits=rh.theNumberOfFoundHits;
    theNumberOfLostHits=rh.theNumberOfLostHits;
    theDirection=rh.theDirection; 
    theDirectionValidity=rh.theDirectionValidity;
    theValid=rh.theValid;
    theNLoops=rh.theNLoops;
    theDPhiCache=rh.theDPhiCache;
 
    return *this;

  }
  

  TempTrajectory(TempTrajectory && rh) noexcept :
    theData(std::move(rh.theData)),
    theChiSquared(rh.theChiSquared), 
    theNumberOfFoundHits(rh.theNumberOfFoundHits), theNumberOfLostHits(rh.theNumberOfLostHits),
    theDirection(rh.theDirection), theDirectionValidity(rh.theDirectionValidity),
    theValid(rh.theValid),
    theNLoops(rh.theNLoops),
    theDPhiCache(rh.theDPhiCache){}

  TempTrajectory & operator=(TempTrajectory && rh) noexcept {
    using std::swap;
    swap(theData,rh.theData);
    theChiSquared=rh.theChiSquared;
    theNumberOfFoundHits=rh.theNumberOfFoundHits;
    theNumberOfLostHits=rh.theNumberOfLostHits;
    theDirection=rh.theDirection;
    theDirectionValidity=rh.theDirectionValidity;
    theValid=rh.theValid;
    theNLoops=rh.theNLoops;
    theDPhiCache=rh.theDPhiCache;
    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 lostHits() const { return theNumberOfLostHits;}
  
  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++;}


private:
  static bool lost( const TrackingRecHit& hit) dso_internal;


  void pushAux(double chi2Increment);

private:

  DataContainer theData;

  float theChiSquared;

  signed short theNumberOfFoundHits;
  signed short theNumberOfLostHits;

  // PropagationDirection 
  signed char theDirection;
  bool        theDirectionValidity;
  bool theValid;

  signed char theNLoops;
  float theDPhiCache;


  void check() const;
};

#endif