GroupedCkfTrajectoryBuilder.h

Go to the documentation of this file.

#ifndef GroupedCkfTrajectoryBuilder_H
#define GroupedCkfTrajectoryBuilder_H

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.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 {}

  static void fillPSetDescription(edm::ParameterSetDescription& iDesc);

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