NuclearInteractionFinder.h

Go to the documentation of this file.

#ifndef CD_NuclearInteractionFinder_H_
#define CD_NuclearInteractionFinder_H_
 
//----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
#include "TrackingTools/PatternTools/interface/TrajectoryStateUpdator.h"
#include "TrackingTools/PatternTools/interface/Trajectory.h"
#include "TrackingTools/TrackFitters/interface/TrajectoryFitter.h"
#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h"
#include "TrackingTools/DetLayers/interface/MeasurementEstimator.h"
#include "TrackingTools/MeasurementDet/interface/LayerMeasurements.h"
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ESHandle.h"
 
#include "RecoTracker/MeasurementDet/interface/MeasurementTracker.h"
#include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h"
#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"
 
#include "MagneticField/Engine/interface/MagneticField.h"
 
#include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h"
 
#include "RecoTracker/NuclearSeedGenerator/interface/NuclearTester.h"
#include "RecoTracker/NuclearSeedGenerator/interface/SeedFromNuclearInteraction.h"
#include "RecoTracker/NuclearSeedGenerator/interface/TangentHelix.h"
 
#include "TrackingTools/DetLayers/interface/NavigationSchool.h"
 
class NuclearInteractionFinder {
private:
  typedef TrajectoryStateOnSurface TSOS;
  typedef FreeTrajectoryState FTS;
  typedef TrajectoryMeasurement TM;
  typedef std::vector<Trajectory> TrajectoryContainer;
  typedef TrajectoryMeasurement::ConstRecHitPointer ConstRecHitPointer;
 
  void fillSeeds(const std::pair<TrajectoryMeasurement, std::vector<TrajectoryMeasurement> >& tmPairs);
 
  std::vector<TrajectoryMeasurement> findCompatibleMeasurements(const TM& lastMeas,
                                                                double rescaleFactor,
                                                                const LayerMeasurements& layerMeasurements) const;
 
  std::vector<TrajectoryMeasurement> findMeasurementsFromTSOS(const TSOS& currentState,
                                                              DetId detid,
                                                              const LayerMeasurements& layerMeasurements) const;
 
  void definePrimaryHelix(std::vector<TrajectoryMeasurement>::const_iterator it_meas);
 
public:
  NuclearInteractionFinder() {}
 
  NuclearInteractionFinder(const edm::EventSetup& es, const edm::ParameterSet& iConfig);
 
  virtual ~NuclearInteractionFinder();
 
  bool run(const Trajectory& traj, const MeasurementTrackerEvent& event);
 
  void improveSeeds(const MeasurementTrackerEvent& event);
 
  std::unique_ptr<TrajectorySeedCollection> getPersistentSeeds();
 
  TrajectoryStateOnSurface rescaleError(float rescale, const TSOS& state) const;
 
  const NavigationSchool* nav() const { return theNavigationSchool; }
 
private:
  const Propagator* thePropagator;
  const MeasurementEstimator* theEstimator;
  const MeasurementTracker* theMeasurementTracker;
  const GeometricSearchTracker* theGeomSearchTracker;
  const NavigationSchool* theNavigationSchool;
  edm::ESHandle<MagneticField> theMagField;
 
  NuclearTester* nuclTester;
  SeedFromNuclearInteraction* currentSeed;
  std::vector<SeedFromNuclearInteraction> allSeeds;
  TangentHelix* thePrimaryHelix;
 
  // parameters
  double ptMin;
  unsigned int maxHits;
  double rescaleErrorFactor;
  bool checkCompletedTrack; 
  std::string navigationSchoolName;
};
#endif