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 "FWCore/Utilities/interface/Visibility.h"
 
#include <vector>
#include <algorithm>
#include <limits>
#include "TrackingTools/PatternTools/interface/bqueue.h"
 
#include "TrackingTools/PatternTools/interface/Trajectory.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