TrackTransformer.h

Go to the documentation of this file.

#ifndef TrackingTools_TrackRefitter_TrackTransformer_H
#define TrackingTools_TrackRefitter_TrackTransformer_H

#include "TrackingTools/TrackRefitter/interface/TrackTransformerBase.h"

#include "TrackingTools/TrackRefitter/interface/RefitDirection.h"

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

#include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h"

#include "DataFormats/TrackReco/interface/TrackFwd.h"

namespace edm {class ParameterSet; class EventSetup; class ParameterSetDescription;}
namespace reco {class TransientTrack;}

class TrajectoryFitter;
class TrajectorySmoother;
class Propagator;
class TransientTrackingRecHitBuilder;
class Trajectory;

class TrackTransformer final : public TrackTransformerBase{

public:

  explicit TrackTransformer(const edm::ParameterSet&);

  ~TrackTransformer() override;

  static void fillPSetDescription(edm::ParameterSetDescription& descriptions,
                  bool DoPredictionsOnly=false,
                  const std::string& Fitter="KFFitterForRefitInsideOut",
                  const std::string& Smoother="KFSmootherForRefitInsideOut",
                  const std::string& Propagator="SmartPropagatorAnyRK",
                  const std::string& RefitDirection="alongMomentum",
                  bool RefitRPCHits=true,
                  const std::string& TrackerRecHitBuilder="WithTrackAngle",
                  const std::string& MuonRecHitBuilder="MuonRecHitBuilder",
                  const std::string& MTDRecHitBuilder="MTDRecHitBuilder");
  
  // Operations

  std::vector<Trajectory> transform(const reco::Track&) const override;

  std::vector<Trajectory> transform(const reco::TrackRef&) const;

  std::vector<Trajectory> transform(const reco::TransientTrack&,
                                    TransientTrackingRecHit::ConstRecHitContainer&) const;

  const MagneticField* magneticField() const {return &*theMGField;}
  
  edm::ESHandle<GlobalTrackingGeometry> trackingGeometry() const {return theTrackingGeometry;}

  void setServices(const edm::EventSetup&) override;

  std::unique_ptr<TrajectoryFitter> const & refitter() const {return theFitter;}
  
  std::unique_ptr<TrajectorySmoother> const &  smoother() const {return theSmoother;}

  TransientTrackingRecHit::ConstRecHitContainer
    getTransientRecHits(const reco::TransientTrack& track) const;
  
 private:

 RefitDirection::GeometricalDirection
    checkRecHitsOrdering(TransientTrackingRecHit::ConstRecHitContainer const&) const;

  
  unsigned long long theCacheId_TC=0;
  unsigned long long theCacheId_GTG=0;
  unsigned long long theCacheId_MG=0;
  unsigned long long theCacheId_TRH=0;
  
  const bool theRPCInTheFit;

  const bool theDoPredictionsOnly;
  const RefitDirection theRefitDirection;

  edm::ESHandle<GlobalTrackingGeometry> theTrackingGeometry;
  edm::ESHandle<MagneticField> theMGField;
  
  const std::string theFitterName;
  std::unique_ptr<TrajectoryFitter> theFitter;
  
  const std::string theSmootherName;
  std::unique_ptr<TrajectorySmoother> theSmoother;
 
  const std::string thePropagatorName;
  edm::ESHandle<Propagator> const & propagator() const {return thePropagator;}
  edm::ESHandle<Propagator> thePropagator;

  const std::string theTrackerRecHitBuilderName;
  edm::ESHandle<TransientTrackingRecHitBuilder> theTrackerRecHitBuilder;
  TkClonerImpl hitCloner;
  
  const std::string theMuonRecHitBuilderName;
  edm::ESHandle<TransientTrackingRecHitBuilder> theMuonRecHitBuilder;

  const std::string theMTDRecHitBuilderName;
  bool theMtdAvailable;
  edm::ESHandle<TransientTrackingRecHitBuilder> theMTDRecHitBuilder;
};
#endif