SeedFromNuclearInteraction.h

Go to the documentation of this file.

#ifndef SeedFromNuclearInteraction_H
#define SeedFromNuclearInteraction_H

#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"

#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"

#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h"

#include "RecoTracker/NuclearSeedGenerator/interface/TangentHelix.h"

class FreeTrajectoryState;

class SeedFromNuclearInteraction {
private:
  typedef TrajectoryMeasurement TM;
  typedef TrajectoryStateOnSurface TSOS;
  typedef edm::OwnVector<TrackingRecHit> recHitContainer;
  typedef TransientTrackingRecHit::ConstRecHitPointer ConstRecHitPointer;
  typedef std::vector<ConstRecHitPointer> ConstRecHitContainer;

public:
  SeedFromNuclearInteraction(const Propagator* prop, const TrackerGeometry* geom, double ptMin);

  virtual ~SeedFromNuclearInteraction() {}

  void setMeasurements(const TSOS& tsosAtInteractionPoint, ConstRecHitPointer ihit, ConstRecHitPointer ohit);

  void setMeasurements(TangentHelix& primHelix,
                       const TSOS& inner_TSOS,
                       ConstRecHitPointer ihit,
                       ConstRecHitPointer ohit);

  PTrajectoryStateOnDet const& trajectoryState() const { return pTraj; }

  FreeTrajectoryState* stateWithError() const;

  FreeTrajectoryState* stateWithError(TangentHelix& helix) const;

  PropagationDirection direction() const { return alongMomentum; }

  recHitContainer hits() const;

  TrajectorySeed TrajSeed() const { return TrajectorySeed(trajectoryState(), hits(), direction()); }

  bool isValid() const { return isValid_; }

  const TSOS& updatedTSOS() const { return *updatedTSOS_; }

  const TSOS& initialTSOS() const { return *initialTSOS_; }

  GlobalPoint outerHitPosition() const {
    return theTrackerGeom->idToDet(outerHitDetId())->surface().toGlobal(outerHit_->localPosition());
  }

  DetId outerHitDetId() const { return outerHit_->geographicalId(); }

  ConstRecHitPointer outerHit() const { return outerHit_; }

  AlgebraicMatrix33 rotationMatrix(const GlobalVector& perp) const;

private:
  bool isValid_; 
  ConstRecHitContainer theHits; 
                                /*   initial freeTS and to be fitted       */

  ConstRecHitPointer innerHit_; 
  ConstRecHitPointer outerHit_; 
  std::shared_ptr<TSOS> updatedTSOS_; 
  std::shared_ptr<TSOS> initialTSOS_; 
  std::shared_ptr<FreeTrajectoryState> freeTS_; 
  PTrajectoryStateOnDet pTraj; 
  // input parameters

  double ptMin; 
  const Propagator* thePropagator;
  const TrackerGeometry* theTrackerGeom;

  bool construct();
};
#endif