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>


#include "FWCore/Utilities/interface/Visibility.h"


class dso_internal GroupedCkfTrajectoryBuilder final : public BaseCkfTrajectoryBuilder {
  
 public:
  GroupedCkfTrajectoryBuilder(const edm::ParameterSet& conf, edm::ConsumesCollector& iC);

  ~GroupedCkfTrajectoryBuilder() override{}

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

  TrajectoryContainer trajectories(const TrajectorySeed&) const override;

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

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

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

  // also new interface returning the start Trajectory...
  TempTrajectory buildTrajectories (const TrajectorySeed&seed,
                    TrajectoryContainer &ret,
                    unsigned int& nCandPerSeed,
                    const TrajectoryFilter*) const override;



  void  rebuildSeedingRegion(const TrajectorySeed&,
                 TrajectoryContainer& result) const override ;
 
  // same as above using the precomputed startingTraj..
  void  rebuildTrajectories(TempTrajectory const & startingTraj, const TrajectorySeed&,
                 TrajectoryContainer& result) const override ;  


  // 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:
  void setEvent_(const edm::Event& iEvent, const edm::EventSetup& iSetup) override;

  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 :
//  /// no copy constructor
//  GroupedCkfTrajectoryBuilder (const GroupedCkfTrajectoryBuilder&)  = default;
//
//  /// no assignment operator
//  GroupedCkfTrajectoryBuilder& operator= (const GroupedCkfTrajectoryBuilder&)  dso_internal;

  
  inline bool tkxor(bool a, bool b) const  dso_internal {return (a||b) && !(a&&b);}
  // to be ported later

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

  unsigned int groupedLimitedCandidates( const TrajectorySeed& seed,
                                         TempTrajectory const& startingTraj, 
                                         const TrajectoryFilter* regionalCondition,
                                         const Propagator* propagator, 
                                         bool inOut,
                                         TempTrajectoryContainer& result) const  dso_internal;

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

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

  // ** Backward fit of trajectory candidate except seed. Fit result is returned. invalid if fit failed
  // *  remaining hits are returned  remainingHits.
  TempTrajectory backwardFit (TempTrajectory& candidate, unsigned int nSeed,
                  const TrajectoryFitter& fitter,
                  std::vector<const TrackingRecHit*>& remainingHits) const  dso_internal;

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

  void groupedIntermediaryClean(TempTrajectoryContainer& theTrajectories) const  dso_internal;


  static inline PropagationDirection oppositeDirection (PropagationDirection dir) {
    if ( dir==alongMomentum )  return oppositeToMomentum;
    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;   
  bool theKeepOriginalIfRebuildFails;   
  float maxPt2ForLooperReconstruction;

  float maxDPhiForLooperReconstruction;

//  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