FastTSGFromPropagation.h

Go to the documentation of this file.

#ifndef FastSimulation_Muons_FastTSGFromPropagation_H
#define FastSimulation_Muons_FastTSGFromPropagation_H
 
#include "RecoMuon/TrackerSeedGenerator/interface/TrackerSeedGenerator.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
#include "RecoMuon/TrackingTools/interface/MuonServiceProxy.h"
#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h"
#include "TrackingTools/PatternTools/interface/TrajectoryStateUpdator.h"
#include "RecoMuon/TrackingTools/interface/MuonErrorMatrix.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "TrackingTools/MeasurementDet/interface/LayerMeasurements.h"
 
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "SimDataFormats/Track/interface/SimTrackContainer.h"
 
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h"
#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
 
#include "DataFormats/TrackerRecHit2D/interface/FastTrackerRecHitCollection.h"
#include "DataFormats/TrackerRecHit2D/interface/FastTrackerRecHit.h"
 
#include <memory>
 
class LayerMeasurements;
class Chi2MeasurementEstimator;
class Propagator;
class MeasurementTracker;
class GeometricSearchTracker;
class DirectTrackerNavigation;
struct TrajectoryStateTransform;
class SimTrack;
class TrackerGeometry;
class TrackerTopology;
 
class FastTSGFromPropagation : public TrackerSeedGenerator {
public:
  FastTSGFromPropagation(const edm::ParameterSet& pset, edm::ConsumesCollector& iC);
 
  FastTSGFromPropagation(const edm::ParameterSet& par, const MuonServiceProxy*, edm::ConsumesCollector& iC);
 
  ~FastTSGFromPropagation() override;
 
  void trackerSeeds(const TrackCand&,
                    const TrackingRegion&,
                    const TrackerTopology* tTopo,
                    std::vector<TrajectorySeed>&) override;
 
  void init(const MuonServiceProxy*) override;
 
  void setEvent(const edm::Event&) override;
 
private:
  void stateOnDet(const TrajectoryStateOnSurface& ts, unsigned int detid, PTrajectoryStateOnDet& pts) const;
 
  TrajectoryStateOnSurface innerState(const TrackCand&) const;
 
  TrajectoryStateOnSurface outerTkState(const TrackCand&) const;
 
  const TrajectoryStateUpdator* updator() const { return theUpdator.get(); }
 
  const Chi2MeasurementEstimator* estimator() const { return theEstimator.get(); }
 
  edm::ESHandle<Propagator> propagator() const { return theService->propagator(thePropagatorName); }
 
  TrajectorySeed createSeed(const TrajectoryStateOnSurface&, const DetId&) const;
 
  TrajectorySeed createSeed(const TrajectoryStateOnSurface& tsos,
                            const edm::OwnVector<TrackingRecHit>& container,
                            const DetId& id) const;
 
  void validMeasurements(std::vector<TrajectoryMeasurement>&) const;
 
  std::vector<TrajectoryMeasurement> findMeasurements(const DetLayer*, const TrajectoryStateOnSurface&) const;
 
  bool passSelection(const TrajectoryStateOnSurface&) const;
 
  void getRescalingFactor(const TrackCand& staMuon);
 
  void adjust(FreeTrajectoryState&) const;
 
  void adjust(TrajectoryStateOnSurface&) const;
 
  double dxyDis(const TrajectoryStateOnSurface& tsos) const;
 
  double zDis(const TrajectoryStateOnSurface& tsos) const;
 
  struct increasingEstimate {
    bool operator()(const TrajectoryMeasurement& lhs, const TrajectoryMeasurement& rhs) const {
      return lhs.estimate() < rhs.estimate();
    }
  };
 
  struct isInvalid {
    bool operator()(const TrajectoryMeasurement& measurement) {
      return (((measurement).recHit() == nullptr) || !((measurement).recHit()->isValid()) ||
              !((measurement).updatedState().isValid()));
    }
  };
 
  unsigned long long theCacheId_MT;
  unsigned long long theCacheId_TG;
 
  std::string theCategory;
 
  edm::ESHandle<GeometricSearchTracker> theTracker;
 
  edm::ESHandle<MeasurementTracker> theMeasTracker;
 
  std::unique_ptr<const DirectTrackerNavigation> theNavigation;
 
  const TrackerGeometry* theGeometry;
 
  const MuonServiceProxy* theService;
 
  std::unique_ptr<const TrajectoryStateUpdator> theUpdator;
 
  std::unique_ptr<const Chi2MeasurementEstimator> theEstimator;
 
  double theMaxChi2;
 
  double theFlexErrorRescaling;
 
  double theFixedErrorRescaling;
 
  bool theUseVertexStateFlag;
 
  bool theUpdateStateFlag;
 
  std::string theResetMethod;
 
  bool theSelectStateFlag;
 
  std::string thePropagatorName;
 
  std::unique_ptr<MuonErrorMatrix> theErrorMatrixAdjuster;
 
  bool theAdjustAtIp;
 
  double theSigmaZ;
 
  const edm::ParameterSet theConfig;
  edm::EDGetTokenT<edm::SimTrackContainer> theSimTrackCollectionToken_;
  edm::EDGetTokenT<FastTrackerRecHitCombinationCollection> recHitCombinationsToken_;
  edm::EDGetTokenT<reco::BeamSpot> beamSpot_;
  edm::EDGetTokenT<MeasurementTrackerEvent> theMeasurementTrackerEventToken_;
 
  edm::Handle<reco::BeamSpot> theBeamSpot;
  edm::Handle<edm::SimTrackContainer> theSimTracks;
  edm::Handle<FastTrackerRecHitCombinationCollection> recHitCombinations;
  edm::Handle<MeasurementTrackerEvent> theMeasTrackerEvent;
  edm::ESHandle<TransientTrackingRecHitBuilder> theTTRHBuilder;
};
 
#endif