GenericProjectedRecHit2D.h

Go to the documentation of this file.

#ifndef RECOTRACKER_TRANSIENTRACKINGRECHIT_GenericProjectedRecHit2D_H
#define RECOTRACKER_TRANSIENTRACKINGRECHIT_GenericProjectedRecHit2D_H
 
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
#include "TrackingTools/TransientTrackingRecHit/interface/HelpertRecHit2DLocalPos.h"
#include "TrackingTools/KalmanUpdators/interface/TrackingRecHitPropagator.h"
 
class GenericProjectedRecHit2D : public TransientTrackingRecHit {
public:
  GenericProjectedRecHit2D(const LocalPoint& pos,
                           const LocalError& err,
                           const GeomDet* det,
                           const GeomDet* originaldet,
                           const TransientTrackingRecHit::ConstRecHitPointer originalHit,
                           const TrackingRecHitPropagator* propagator);
 
  AlgebraicSymMatrix parametersError() const override {
    return HelpertRecHit2DLocalPos().parError(localPositionError(), *det());
  }
 
  //virtual ~GenericProjectedRecHit2D(){delete theOriginalTransientHit;}
 
  AlgebraicVector parameters() const override;
 
  LocalPoint localPosition() const override { return theLp; }
 
  LocalError localPositionError() const override { return theLe; }
 
  AlgebraicMatrix projectionMatrix() const override { return theProjectionMatrix; }
 
  virtual DetId geographicalId() const { return det() ? det()->geographicalId() : DetId(); }
 
  int dimension() const override { return theDimension; }
 
  //this hit lays on the original surface, NOT on the projection surface
  const TrackingRecHit* hit() const override { return theOriginalTransientHit->hit(); }
 
  TrackingRecHit* cloneHit() const override { return theOriginalTransientHit->cloneHit(); }
 
  virtual bool isValid() const { return true; }
 
  std::vector<const TrackingRecHit*> recHits() const override {
    //return theOriginalTransientHit->hit()->recHits();
    return std::vector<const TrackingRecHit*>();
  }
 
  std::vector<TrackingRecHit*> recHits() override {
    //should it do something different?
    return std::vector<TrackingRecHit*>();
  }
 
  const TrackingRecHitPropagator* propagator() const { return thePropagator; }
 
  bool canImproveWithTrack() const override { return true; }
 
  const GeomDet* originalDet() const { return theOriginalDet; }
 
  static RecHitPointer build(const LocalPoint& pos,
                             const LocalError& err,
                             const GeomDet* det,
                             const GeomDet* originaldet,
                             const TransientTrackingRecHit::ConstRecHitPointer originalHit,
                             const TrackingRecHitPropagator* propagator) {
    return RecHitPointer(new GenericProjectedRecHit2D(pos, err, det, originaldet, originalHit, propagator));
  }
 
  RecHitPointer clone(const TrajectoryStateOnSurface& ts, const TransientTrackingRecHitBuilder*) const;
 
private:
  const GeomDet* theOriginalDet;
  TransientTrackingRecHit::ConstRecHitPointer theOriginalTransientHit;
  LocalPoint theLp;
  LocalError theLe;
  AlgebraicMatrix theProjectionMatrix;
  const TrackingRecHitPropagator* thePropagator;
  //const TrackingRecHit* theOriginalHit;
  int theDimension;
 
  GenericProjectedRecHit2D* clone() const override { return new GenericProjectedRecHit2D(*this); }
};
 
#endif