BaseCkfTrajectoryBuilder.h

Go to the documentation of this file.

#ifndef RecoTracker_CkfPattern_BaseCkfTrajectoryBuilder_h
#define RecoTracker_CkfPattern_BaseCkfTrajectoryBuilder_h

#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h"
#include "TrackingTools/PatternTools/interface/TrajectoryBuilder.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

class CkfDebugger;
class Chi2MeasurementEstimatorBase;
class DetGroup;
class FreeTrajectoryState;
class IntermediateTrajectoryCleaner;
class LayerMeasurements;
class MeasurementTracker;
class MeasurementEstimator;
class NavigationSchool;
class Propagator;
class TrajectoryStateUpdator;
class TrajectoryMeasurement;
class TrajectorySeed;
class TrajectoryContainer;
class TrajectoryStateOnSurface;
class TrajectoryFitter;
class TransientTrackingRecHitBuilder;
class Trajectory;
class TempTrajectory;
class TrajectoryFilter;
class TrackingRegion;
class TrajectoryMeasurementGroup;
class TrajectoryCleaner;

#include "TrackingTools/PatternTools/interface/bqueue.h"
#include "RecoTracker/CkfPattern/interface/PrintoutHelper.h"

class BaseCkfTrajectoryBuilder : public TrajectoryBuilder {
protected:
  // short names
  typedef FreeTrajectoryState         FTS;
  typedef TrajectoryStateOnSurface    TSOS;
  typedef TrajectoryMeasurement       TM;
  typedef std::pair<TSOS,std::vector<const DetLayer*> > StateAndLayers;

public:

  typedef std::vector<Trajectory> TrajectoryContainer;
  typedef std::vector<TempTrajectory> TempTrajectoryContainer;
  typedef TrajectoryContainer::iterator TrajectoryIterator;
  
  BaseCkfTrajectoryBuilder(const edm::ParameterSet&              conf,
               const TrajectoryStateUpdator*         updator,
               const Propagator*                     propagatorAlong,
               const Propagator*                     propagatorOpposite,
               const Chi2MeasurementEstimatorBase*   estimator,
               const TransientTrackingRecHitBuilder* RecHitBuilder,
               const MeasurementTracker*             measurementTracker,
               const TrajectoryFilter*               filter,
               const TrajectoryFilter*               inOutFilter = 0);

  virtual ~BaseCkfTrajectoryBuilder();

  virtual TrajectoryContainer trajectories(const TrajectorySeed&) const = 0;

  virtual void setEvent(const edm::Event& event) const;
  virtual void unset() const;

  virtual void setDebugger( CkfDebugger * dbg) const {;}
 
  //  int       maxLostHit()        {return theMaxLostHit;}

  //  int       maxConsecLostHit()  {return theMaxConsecLostHit;}

 protected:    
  //methods for dubugging 
  virtual bool analyzeMeasurementsDebugger(Trajectory& traj, std::vector<TrajectoryMeasurement> meas,
                       const MeasurementTracker* theMeasurementTracker, 
                       const Propagator* theForwardPropagator, 
                       const Chi2MeasurementEstimatorBase* theEstimator, 
                       const TransientTrackingRecHitBuilder * theTTRHBuilder) const {return true;} 
  virtual bool analyzeMeasurementsDebugger(TempTrajectory& traj, std::vector<TrajectoryMeasurement> meas,
                       const MeasurementTracker* theMeasurementTracker, 
                       const Propagator* theForwardPropagator, 
                       const Chi2MeasurementEstimatorBase* theEstimator, 
                       const TransientTrackingRecHitBuilder * theTTRHBuilder) const {return true;} 
  virtual void fillSeedHistoDebugger(std::vector<TrajectoryMeasurement>::iterator begin, 
                                     std::vector<TrajectoryMeasurement>::iterator end) const {;}

 protected:

  TempTrajectory createStartingTrajectory( const TrajectorySeed& seed) const;

  // If inOut is true, this is being called part-way through tracking, after the in-out tracking phase is complete.
  // If inOut is false, it is called at the end of tracking.
  bool toBeContinued( TempTrajectory& traj, bool inOut = false) const;

  bool qualityFilter( const TempTrajectory& traj, bool inOut = false) const;
  
  void addToResult( TempTrajectory& traj, TrajectoryContainer& result, bool inOut = false) const;    
  void addToResult( TempTrajectory& traj, TempTrajectoryContainer& result, bool inOut = false) const;    

  StateAndLayers findStateAndLayers(const TempTrajectory& traj) const;

 private:
  void seedMeasurements(const TrajectorySeed& seed, std::vector<TrajectoryMeasurement> & result) const;



 protected:
  const TrajectoryStateUpdator*         theUpdator;
  const Propagator*                     thePropagatorAlong;
  const Propagator*                     thePropagatorOpposite;
  const Chi2MeasurementEstimatorBase*   theEstimator;
  const TransientTrackingRecHitBuilder* theTTRHBuilder;
  const MeasurementTracker*             theMeasurementTracker;
  const LayerMeasurements*              theLayerMeasurements;

  // these may change from seed to seed
  mutable const Propagator*             theForwardPropagator;
  mutable const Propagator*             theBackwardPropagator;

 private:
  //  int theMaxLostHit;            /**< Maximum number of lost hits per trajectory candidate.*/
  //  int theMaxConsecLostHit;      /**< Maximum number of consecutive lost hits 
  //                                     per trajectory candidate. */
  //  int theMinimumNumberOfHits;   /**< Minimum number of hits for a trajectory to be returned.*/
  //  float theChargeSignificance;  /**< Value to declare (q/p)/sig(q/p) significant. Negative: ignore. */

  //  TrajectoryFilter*              theMinPtCondition;
  //  TrajectoryFilter*              theMaxHitsCondition;
  const TrajectoryFilter* theFilter; 
  const TrajectoryFilter* theInOutFilter; 
  bool skipClusters_;
  edm::InputTag clustersToSkip_;
};


#endif