/data/refman/pasoursint/CMSSW_4_1_8_patch12/src/RecoTracker/TrackProducer/interface/TrackProducerAlgorithm.h

Go to the documentation of this file.

#ifndef TrackProducerAlgorithm_h
#define TrackProducerAlgorithm_h

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/Event.h"
#include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackExtra.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
#include "TrackingTools/PatternTools/interface/TrackConstraintAssociation.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"

class MagneticField;
class TrackingGeometry;
class TrajectoryFitter;
class Propagator;
class Trajectory;
class TrajectoryStateOnSurface;
class TransientTrackingRecHitBuilder;


template <class T>
class TrackProducerAlgorithm {
public:
  typedef std::vector<T> TrackCollection;
  typedef std::pair<Trajectory*, std::pair<T*,PropagationDirection> > AlgoProduct; 
  typedef std::vector< AlgoProduct >  AlgoProductCollection;
  typedef edm::RefToBase<TrajectorySeed> SeedRef;
  typedef edm::AssociationMap<edm::OneToOne<std::vector<T>,std::vector<VertexConstraint> > > 
  VtxConstraintAssociationCollection;
 public:

  TrackProducerAlgorithm(const edm::ParameterSet& conf) : 
    conf_(conf),
    algoName_(conf_.getParameter<std::string>( "AlgorithmName" )),
    algo_(reco::TrackBase::algoByName(algoName_)),
    reMatchSplitHits_(false)
      {
        if (conf_.exists("reMatchSplitHits"))
          reMatchSplitHits_=conf_.getParameter<bool>("reMatchSplitHits");
      }

  ~TrackProducerAlgorithm() {}
  
  void runWithCandidate(const TrackingGeometry *, 
                        const MagneticField *, 
                        const TrackCandidateCollection&,
                        const TrajectoryFitter *,
                        const Propagator *,
                        const TransientTrackingRecHitBuilder*,
                        const reco::BeamSpot&,
                        AlgoProductCollection &);

  void runWithTrack(const TrackingGeometry *, 
                    const MagneticField *, 
                    const TrackCollection&,
                    const TrajectoryFitter *,
                    const Propagator *,
                    const TransientTrackingRecHitBuilder*,
                    const reco::BeamSpot&,
                    AlgoProductCollection &);

  void runWithMomentum(const TrackingGeometry *, 
                       const MagneticField *, 
                       const TrackMomConstraintAssociationCollection&,
                       const TrajectoryFitter *,
                       const Propagator *,
                       const TransientTrackingRecHitBuilder*,
                       const reco::BeamSpot&,
                       AlgoProductCollection &);

  void runWithVertex(const TrackingGeometry *, 
                     const MagneticField *, 
                     const VtxConstraintAssociationCollection&,
                     const TrajectoryFitter *,
                     const Propagator *,
                     const TransientTrackingRecHitBuilder*,
                     const reco::BeamSpot&,
                     AlgoProductCollection &);

  bool buildTrack(const TrajectoryFitter *,
                  const Propagator *,
                  AlgoProductCollection& ,
                  TransientTrackingRecHit::RecHitContainer&,
                  TrajectoryStateOnSurface& ,
                  const TrajectorySeed&,                  
                  float,
                  const reco::BeamSpot&,
                  SeedRef seedRef = SeedRef(),
                  int qualityMask=0);

 private:
  edm::ParameterSet conf_;  
  std::string algoName_;
  reco::TrackBase::TrackAlgorithm algo_;
  bool reMatchSplitHits_;

  TrajectoryStateOnSurface getInitialState(const T * theT,
                                           TransientTrackingRecHit::RecHitContainer& hits,
                                           const TrackingGeometry * theG,
                                           const MagneticField * theMF);

};

#include "RecoTracker/TrackProducer/interface/TrackProducerAlgorithm.icc"

template <> bool
TrackProducerAlgorithm<reco::Track>::buildTrack(const TrajectoryFitter *,
                                                const Propagator *,
                                                AlgoProductCollection& ,
                                                TransientTrackingRecHit::RecHitContainer&,
                                                TrajectoryStateOnSurface& ,
                                                const TrajectorySeed&,
                                                float,
                                                const reco::BeamSpot&,
                                                SeedRef seedRef,
                                                int qualityMask);


template <> bool
TrackProducerAlgorithm<reco::GsfTrack>::buildTrack(const TrajectoryFitter *,
                                                   const Propagator *,
                                                   AlgoProductCollection& ,
                                                   TransientTrackingRecHit::RecHitContainer&,
                                                   TrajectoryStateOnSurface& ,
                                                   const TrajectorySeed&,
                                                   float,
                                                   const reco::BeamSpot&,
                                                   SeedRef seedRef,
                                                   int qualityMask);

#endif