GroupedCkfTrajectoryBuilder.h

Go to the documentation of this file.

#ifndef GroupedCkfTrajectoryBuilder_H
#define GroupedCkfTrajectoryBuilder_H

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/EventSetup.h"

#include "RecoTracker/CkfPattern/interface/BaseCkfTrajectoryBuilder.h"
#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h"

#include "TrackingTools/PatternTools/interface/TempTrajectory.h"

#include <vector>




class GroupedCkfTrajectoryBuilder : public BaseCkfTrajectoryBuilder {
  
 public:
  GroupedCkfTrajectoryBuilder(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);

  virtual ~GroupedCkfTrajectoryBuilder(){}

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

  TrajectoryContainer trajectories(const TrajectorySeed&) const;

  void trajectories(const TrajectorySeed&, TrajectoryContainer &ret) const;

  TrajectoryContainer trajectories(const TrajectorySeed&, const TrackingRegion&) const;

  void trajectories(const TrajectorySeed&, TrajectoryContainer &ret, const TrackingRegion&) const;

  void  rebuildSeedingRegion(const TrajectorySeed&,
                 TrajectoryContainer& result) const ;  

  // Access to lower level components
  const TrajectoryStateUpdator&  updator() const    {return *theUpdator;}
  const Chi2MeasurementEstimatorBase&    estimator() const  {return *theEstimator;}

  //   PropagationDirection        direction() const  {return theDirection;}

  double    chiSquareCut()      {return theChiSquareCut;}

  int       maxCand()       {return theMaxCand;}


  float     lostHitPenalty()    {return theLostHitPenalty;}

  //   /** Tells whether an intermediary cleaning stage should take place during TB. */
  //   bool         intermediateCleaning()  {return theIntermediateCleaning;}

  double ptCut() {return theptCut;}

  double mass() {return theMass;}

protected:

  virtual void analyseSeed(const TrajectorySeed& seed) const{}

  virtual void analyseMeasurements( const std::vector<TM>& meas, 
                    const Trajectory& traj) const{}
  virtual void analyseResult( const TrajectoryContainer& result) const {}

private :
  GroupedCkfTrajectoryBuilder (const GroupedCkfTrajectoryBuilder&);

  GroupedCkfTrajectoryBuilder& operator= (const GroupedCkfTrajectoryBuilder&);

  void buildTrajectories (const TrajectorySeed&,
                                  TrajectoryContainer &ret,
                              const TrajectoryFilter*) const;
  
  inline bool tkxor(bool a, bool b) const {return (a||b) && !(a&&b);}
  // to be ported later

  bool advanceOneLayer( TempTrajectory& traj, 
            const TrajectoryFilter* regionalCondition,
            const Propagator* propagator, 
                        bool inOut,
            TempTrajectoryContainer& newCand, 
            TempTrajectoryContainer& result) const;

  void groupedLimitedCandidates( TempTrajectory& startingTraj, 
                 const TrajectoryFilter* regionalCondition,
                 const Propagator* propagator, 
                                 bool inOut,
                 TempTrajectoryContainer& result) const;

  void rebuildSeedingRegion (TempTrajectory& startingTraj,
                 TempTrajectoryContainer& result) const ;

   //** try to find additional hits in seeding region for a candidate
   //* (returns number of trajectories added) *
  int rebuildSeedingRegion (const std::vector<const TrackingRecHit*>& seedHits,
                TempTrajectory& candidate,
                TempTrajectoryContainer& result) const ;

  // ** Backward fit of trajectory candidate except seed. Fit result and
  // *  remaining hits are returned in fittedTracks and remainingHits.
  // *  FittedTracks is empty if no fit was done. *
  void backwardFit (TempTrajectory& candidate, unsigned int nSeed,
            const TrajectoryFitter& fitter,
            TempTrajectoryContainer& fittedTracks,
            std::vector<const TrackingRecHit*>& remainingHits) const;

  bool verifyHits (TempTrajectory::DataContainer::const_iterator rbegin,
           size_t maxDepth,
           const std::vector<const TrackingRecHit*>& hits) const;

  void groupedIntermediaryClean(TempTrajectoryContainer& theTrajectories) const ;

  void layers (const TempTrajectory::DataContainer& measurements,
               std::vector<const DetLayer*> &fillme) const;

  inline PropagationDirection oppositeDirection (PropagationDirection dir) const {
    if ( dir==alongMomentum )  return oppositeToMomentum;
    else if ( dir==oppositeToMomentum )  return alongMomentum;
    return dir;
  }


private:
  TrajectoryFilter*              theConfigurableCondition;

  //   typedef deque< const TrajectoryFilter*>   StopCondContainer;
  //   StopCondContainer              theStopConditions;

  double theChiSquareCut;       
  double theptCut;              
  double theMass;               
  int theMaxCand;               
  float theLostHitPenalty;      
  float theFoundHitBonus;       
  bool theIntermediateCleaning; 
  bool theAlwaysUseInvalid;

  bool theLockHits;             
  bool theBestHitOnly;          
  bool theRequireSeedHitsInRebuild; 
  unsigned int theMinNrOfHitsForRebuild;     
  unsigned int theMinNrOf2dHitsForRebuild;   
  mutable TempTrajectoryContainer work_; // Better here than alloc every time
  enum work_MaxSize_Size_ { work_MaxSize_ = 50 };  // if it grows above this number, it is forced to resize to half this amount when cleared
};

#endif