MuonRoadTrajectoryBuilder.h

Go to the documentation of this file.

#ifndef RecoMuon_L3TrackFinder_MuonRoadTrajectoryBuilder_h
#define RecoMuon_L3TrackFinder_MuonRoadTrajectoryBuilder_h

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include <DataFormats/TrajectorySeed/interface/TrajectorySeed.h>
#include <DataFormats/TrackReco/interface/Track.h>

#include <DataFormats/GeometryVector/interface/GlobalPoint.h>
#include <DataFormats/GeometryVector/interface/GlobalVector.h>
#include <DataFormats/GeometrySurface/interface/BoundCylinder.h>
#include <DataFormats/GeometrySurface/interface/BoundDisk.h>

#include <Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h>
#include <RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h>

#include <TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h>
#include <TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h>
#include <TrackingTools/PatternTools/interface/Trajectory.h>
#include <TrackingTools/KalmanUpdators/interface/Chi2MeasurementEstimator.h>
#include <TrackingTools/PatternTools/interface/TrajectoryStateUpdator.h>
#include <TrackingTools/PatternTools/interface/TrajectorySmoother.h>
#include <TrackingTools/TrackFitters/interface/KFTrajectorySmoother.h>

#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
#include <TrackingTools/DetLayers/interface/DetLayer.h>

#include <MagneticField/Engine/interface/MagneticField.h>

#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/Event.h"

#include "TrackingTools/PatternTools/interface/TrajectoryBuilder.h"
#include "TrackingTools/GeomPropagators/interface/Propagator.h"


#include <vector>

class MuonRoadTrajectoryBuilder :public TrajectoryBuilder {
 public:
   MuonRoadTrajectoryBuilder(const edm::ParameterSet & par,const MeasurementTracker * mt,const MagneticField * f,const Propagator * p);

   ~MuonRoadTrajectoryBuilder();
     
   void setEvent(const edm::Event&) const ;
     
   std::vector<Trajectory> trajectories(const TrajectorySeed & seed) const ;

   void trajectories(const TrajectorySeed & seed, TrajectoryContainer &ret) const ; 
     
 private:
     
   std::string theCategory ;
   
 public:
   class trajectory {
                 public:
     trajectory():duplicate(false),chi2(0),missed(0),lastmissed(false),missedinarow(0){;}
     bool duplicate;
     double chi2;
     int missed;
     bool lastmissed;
     int missedinarow;
     std::list <TrajectoryMeasurement > measurements;
     TrajectoryStateOnSurface TSOS;
     Trajectory traj; //the only thing to keep eventually
   };
 private:
   
   template <class A> class flippingPair : public std::pair<A,A>{
   public:
     flippingPair(): theFlip(false) {;}
     void flip(){theFlip=!theFlip;}
     A & head(){ if (theFlip) return this->first ;else return this->second;}
     A & tail(){if (theFlip) return this->second ;else return this->first;}
   private:
     bool theFlip;
   };
   
   typedef std::list< trajectory > TrajectoryCollection;
   typedef flippingPair<TrajectoryCollection> TrajectoryCollectionFPair ;
   
   //  const MuonServiceProxy * theProxyService;
   
   void makeTrajectories(const TrajectorySeed & seed, std::vector<Trajectory> & result ,int version=0) const ;
   void makeTrajectories_0(const TrajectorySeed & seed, std::vector<Trajectory> & result) const ;
   int GatherHits(const TrajectoryStateOnSurface & step,const DetLayer * thislayer, TrajectoryCollectionFPair & Trajectories,
                  bool & firstLayer, unsigned int theNumberOfHitPerModule) const;
   void makeTrajectories_1(const TrajectorySeed & seed, std::vector<Trajectory> & result) const ;
      
   bool checkStep(TrajectoryCollection & collection, unsigned int& theNumberOfHitPerModule) const ;
   void checkDuplicate(TrajectoryCollection & collection) const ;
          
   Trajectory smooth(Trajectory &) const ;
   void cleanTrajectory(Trajectory & traj) const ;
          
   //algorithm options
   //limit the total number of possible trajectories taken into account for a single seed
   unsigned int theMaxTrajectories;
          
   //limit the type of module considered to gather rechits
   bool theDynamicMaxNumberOfHitPerModule;
   unsigned int theNumberOfHitPerModuleDefault;
   std::vector<unsigned int> theMaxTrajectoriesThreshold;
   std::vector<unsigned int> theNumberOfHitPerModuleThreshold;
  
   //fixed parameters
   bool theBranchonfirstlayer;
   bool theCarriedIPatfirstlayer;
   bool theCarriedIPatfirstlayerModule;
  
   //output track candidate selection
   unsigned int  theMinNumberOfHitOnCandidate;
   bool theOutputAllTraj;
  
  
   //tools and usefull pointers
   const MeasurementTracker * theMeasurementTracker;
   const MeasurementTrackerEvent * theMeasurementTrackerEvent;
    
   //kalman tools
   Chi2MeasurementEstimator * theRoadEstimator;
   Chi2MeasurementEstimator * theHitEstimator;
   TrajectoryStateUpdator * theUpdator;
   KFTrajectorySmoother * theSmoother;
   
   
   
   const MagneticField * theField;
   
   const Propagator * thePropagator;
   
};


#endif