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

#include <vector>
#include <algorithm>
#include <boost/shared_ptr.hpp>
#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 TransientTrackingRecHit::ConstRecHitContainer        ConstRecHitContainer;
  typedef ConstRecHitContainer                                 RecHitContainer;


  TempTrajectory() :  
    theChiSquared(0),
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(alongMomentum), theDirectionValidity(false), 
    theValid(true),theDPhiCache(0),theNLoops(0)
  {}
  
  
  TempTrajectory( const TrajectorySeed& seed) : 
    theSeed( new TrajectorySeed(seed) ),
    theChiSquared(0),
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(alongMomentum), theDirectionValidity(false),
    theValid(true),theDPhiCache(0),theNLoops(0)  
  {}
  
  TempTrajectory( const TrajectorySeed& seed, PropagationDirection dir) : 
    theSeed( new TrajectorySeed(seed) ),
    theChiSquared(0), 
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(dir), theDirectionValidity(true),
    theValid(true),theDPhiCache(0),theNLoops(0)
  {}
  
  TempTrajectory( const boost::shared_ptr<const TrajectorySeed> & seed, PropagationDirection dir) : 
    theSeed( seed ),
    theChiSquared(0), 
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(dir), theDirectionValidity(true),
    theValid(true),theDPhiCache(0),theNLoops(0)
  {}
  
  
  TempTrajectory(PropagationDirection dir) : 
    theChiSquared(0), 
    theNumberOfFoundHits(0), theNumberOfLostHits(0),
    theDirection(dir), theDirectionValidity(true),
    theValid(true),theDPhiCache(0),theNLoops(0)
  {}

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

  }
  

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

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

  }


#endif



  TempTrajectory( const Trajectory& traj);

  // trivial destructor, but must be out-of-line for code size issues
  // https://hypernews.cern.ch/HyperNews/CMS/get/code-perf/247.html
  ~TempTrajectory() ;

  void push( const TrajectoryMeasurement& tm);
#if defined( __GXX_EXPERIMENTAL_CXX0X__)
  void push(TrajectoryMeasurement&& tm);
#endif

  void push( const TempTrajectory & segment);
 
  void join( TempTrajectory & segment);



  void push( const TrajectoryMeasurement& tm, double chi2Increment);
#if defined( __GXX_EXPERIMENTAL_CXX0X__)
  void push( TrajectoryMeasurement&& tm, double chi2Increment);
#endif

  void pop();

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

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

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

  //ConstRecHitContainer recHits() const;

  int foundHits() const { return theNumberOfFoundHits;}

  int lostHits() const { return theNumberOfLostHits;}
  
  bool empty() const { return theData.empty();}

  double chiSquared() const { return theChiSquared;}

  PropagationDirection direction() const;

  bool isValid() const { return theValid;}

  void invalidate() { theValid = false;}

  const TrajectorySeed & seed() const { return *theSeed;}


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

  static bool lost( const TransientTrackingRecHit& hit);

  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:

  void pushAux( const TrajectoryMeasurement& tm, double chi2Increment);

private:


  boost::shared_ptr<const TrajectorySeed>    theSeed;
  DataContainer theData;

  float theChiSquared;

  signed short theNumberOfFoundHits;
  signed short theNumberOfLostHits;

  PropagationDirection theDirection;
  bool                 theDirectionValidity;
  bool theValid;

  float theDPhiCache;
  signed char theNLoops;


  void check() const;
};

#endif