SeedFromConsecutiveHitsCreator.h

Go to the documentation of this file.

#ifndef RecoTracker_TkSeedGenerator_SeedFromConsecutiveHitsCreator_H
#define RecoTracker_TkSeedGenerator_SeedFromConsecutiveHitsCreator_H

#include "RecoTracker/TkSeedGenerator/interface/SeedCreator.h"
#include "RecoTracker/TkSeedingLayers/interface/SeedingHitSet.h"
#include "RecoTracker/TkSeedingLayers/interface/SeedComparitor.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"

#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h"

#include "DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h"
#include "DataFormats/TrackingRecHit/interface/mayown_ptr.h"

namespace edm {
  class ParameterSetDescription;
}
class FreeTrajectoryState;

class dso_hidden SeedFromConsecutiveHitsCreator : public SeedCreator {
public:
  SeedFromConsecutiveHitsCreator(const edm::ParameterSet &cfg)
      : thePropagatorLabel(cfg.getParameter<std::string>("propagator")),
        theBOFFMomentum(cfg.getParameter<double>("SeedMomentumForBOFF")),
        theOriginTransverseErrorMultiplier(cfg.getParameter<double>("OriginTransverseErrorMultiplier")),
        theMinOneOverPtError(cfg.getParameter<double>("MinOneOverPtError")),
        TTRHBuilder(cfg.getParameter<std::string>("TTRHBuilder")),
        mfName_(cfg.getParameter<std::string>("magneticField")),
        forceKinematicWithRegionDirection_(cfg.getParameter<bool>("forceKinematicWithRegionDirection")) {}

  //dtor
  ~SeedFromConsecutiveHitsCreator() override;

  static void fillDescriptions(edm::ParameterSetDescription &desc);
  static const char *fillDescriptionsLabel() { return "ConsecutiveHits"; }

  // initialize the "event dependent state"
  void init(const TrackingRegion &region, const edm::EventSetup &es, const SeedComparitor *filter) final;

  // make job
  // fill seedCollection with the "TrajectorySeed"
  void makeSeed(TrajectorySeedCollection &seedCollection, const SeedingHitSet &hits) final;

private:
  virtual bool initialKinematic(GlobalTrajectoryParameters &kine, const SeedingHitSet &hits) const;

  bool checkHit(const TrajectoryStateOnSurface &tsos, SeedingHitSet::ConstRecHitPointer hit) const dso_hidden;

  CurvilinearTrajectoryError initialError(float sin2Theta) const dso_hidden;

  void buildSeed(TrajectorySeedCollection &seedCollection,
                 const SeedingHitSet &hits,
                 const FreeTrajectoryState &fts) const dso_hidden;

  SeedingHitSet::RecHitPointer refitHit(SeedingHitSet::ConstRecHitPointer hit,
                                        const TrajectoryStateOnSurface &state) const dso_hidden;

protected:
  std::string thePropagatorLabel;
  float theBOFFMomentum;
  float theOriginTransverseErrorMultiplier;
  float theMinOneOverPtError;

  const TrackingRegion *region = nullptr;
  const SeedComparitor *filter = nullptr;
  edm::ESHandle<TrackerGeometry> tracker;
  edm::ESHandle<Propagator> propagatorHandle;
  edm::ESHandle<MagneticField> bfield;
  float nomField;
  bool isBOFF = false;
  std::string TTRHBuilder;
  std::string mfName_;
  bool forceKinematicWithRegionDirection_;

  TkClonerImpl cloner;
};
#endif