Deterministic Annealing Filter for track reconstruction

DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc

@@ -89,7 +89,6 @@
 #include <MagneticField/Engine/interface/MagneticField.h>
 #include <MagneticField/Records/interface/IdealMagneticFieldRecord.h>
 #include <RecoTracker/TransientTrackingRecHit/interface/TSiStripRecHit2DLocalPos.h>
-#include <RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h>
 #include <RecoTracker/TransientTrackingRecHit/interface/TSiPixelRecHit.h>
 #include <RecoTracker/TransientTrackingRecHit/interface/TSiStripRecHit1D.h>
 #include "RecoVertex/VertexPrimitives/interface/TransientVertex.h"
@@ -1104,7 +1103,7 @@ std::vector<double> TrackerDpgAnalysis::onTrackAngles(edm::Handle<edmNew::DetSet
 void TrackerDpgAnalysis::insertMeasurement(std::multimap<const uint32_t,std::pair<LocalPoint,double> >& collection,const TransientTrackingRecHit* hit , double tla)
 {
       if(!hit) return;
-      const TSiTrackerMultiRecHit* multihit=dynamic_cast<const TSiTrackerMultiRecHit*>(hit);
+      const SiTrackerMultiRecHit* multihit=dynamic_cast<const SiTrackerMultiRecHit*>(hit);
       const SiStripRecHit2D* singlehit=dynamic_cast<const SiStripRecHit2D*>(hit);
       const SiStripRecHit1D* hit1d=dynamic_cast<const SiStripRecHit1D*>(hit);
       if(hit1d) { //...->33X

DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h

@@ -16,14 +16,18 @@ class SiTrackerMultiRecHit : public BaseTrackerRecHit
   typedef BaseTrackerRecHit Base;
   SiTrackerMultiRecHit():
     theHits(),
-    theWeights(){}
+    theWeights(),
+    annealing_(0){}
   virtual ~SiTrackerMultiRecHit(){}	
 
 
   SiTrackerMultiRecHit(const LocalPoint&, const LocalError&, GeomDet const & idet,
-		       const std::vector< std::pair<const TrackingRecHit*, float> >&);
+		       const std::vector< std::pair<const TrackingRecHit*, float> >&, double);
 
   virtual SiTrackerMultiRecHit* clone() const {return new SiTrackerMultiRecHit(*this);}
+#ifdef NO_DICT
+  virtual RecHitPointer cloneSH() const { return std::make_shared<SiTrackerMultiRecHit>(*this);}
+#endif
 
   virtual int dimension() const {return 2;}
   virtual void getKfComponents( KfComponentsHolder & holder ) const { getKfComponents2D(holder); }
@@ -32,11 +36,13 @@ class SiTrackerMultiRecHit : public BaseTrackerRecHit
   // used by trackMerger (to be improved)
   virtual OmniClusterRef const & firstClusterRef() const { return static_cast<BaseTrackerRecHit const *>(&theHits.front())->firstClusterRef();}
 
-
-  //vector of component rechits
+  /// Access to component RecHits (if any)
   virtual std::vector<const TrackingRecHit*> recHits() const;
-
+//  virtual void recHitsV(std::vector<const TrackingRecHit*> & ) const;
+
+  /// Non-const access to component RecHits (if any)
   virtual std::vector<TrackingRecHit*> recHits() ;
+//  virtual void recHitsV(std::vector<TrackingRecHit*> & );
 
   //vector of weights
   std::vector<float> const & weights() const {return theWeights;}
@@ -45,14 +51,18 @@ class SiTrackerMultiRecHit : public BaseTrackerRecHit
   //returns the weight for the i component
   float  weight(unsigned int i) const {return theWeights[i];}
   float  & weight(unsigned int i) {return theWeights[i];}
+
+  //get the annealing
+  virtual double getAnnealingFactor() const { return annealing_; }
 
   bool sharesInput(const TrackingRecHit* other,
 		   SharedInputType what) const;
+
 private:
 
   edm::OwnVector<TrackingRecHit> theHits;
   std::vector<float> theWeights;
-
+  double annealing_;	
 
 };
 

DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc

@@ -5,13 +5,14 @@ using namespace std;
 using namespace edm;
 
 SiTrackerMultiRecHit::SiTrackerMultiRecHit(const LocalPoint& pos, const LocalError& err, GeomDet const & idet,
-					   const std::vector< std::pair<const TrackingRecHit*, float> >& aHitMap):
+					   const std::vector< std::pair<const TrackingRecHit*, float> >& aHitMap, double annealing):
   BaseTrackerRecHit(pos,err, idet,trackerHitRTTI::multi)	
 {
   for(std::vector<std::pair<const TrackingRecHit*, float> >::const_iterator ihit = aHitMap.begin(); ihit != aHitMap.end(); ihit++){
     theHits.push_back(ihit->first->clone());
     theWeights.push_back(ihit->second);
   }
+  annealing_ = annealing;
 }
 
 
@@ -68,3 +69,13 @@ vector<TrackingRecHit*> SiTrackerMultiRecHit::recHits() {
   //         }
   return theHits.data();
 }
+
+/*
+void TrackingRecHit::recHitsV(std::vector<const TrackingRecHit*> & v) const {
+  v = recHits();
+}
+
+void TrackingRecHit::recHitsV(std::vector<TrackingRecHit*> & v) {
+  v = recHits();
+}
+*/

DataFormats/TrackerRecHit2D/src/classes_def.xml

@@ -48,7 +48,8 @@
    <version ClassVersion="11" checksum="427184586"/>
    <version ClassVersion="10" checksum="1602539953"/>
   </class>
-  <class name="SiTrackerMultiRecHit" ClassVersion="11">
+  <class name="SiTrackerMultiRecHit" ClassVersion="12">
+   <version ClassVersion="12" checksum="561999321"/>
    <version ClassVersion="11" checksum="2489323248"/>
    <version ClassVersion="10" checksum="2607997209"/>
   </class>

RecoTracker/SiTrackerMRHTools/BuildFile.xml

@@ -0,0 +1,21 @@
+<use   name="DataFormats/GeometryVector"/>
+<use   name="DataFormats/Math"/>
+<use   name="DataFormats/TrackerRecHit2D"/>
+<use   name="FWCore/Framework"/>
+<use   name="FWCore/MessageLogger"/>
+<use   name="FWCore/Utilities"/>
+<use   name="RecoTracker/MeasurementDet"/>
+<use   name="RecoTracker/TkDetLayers"/>
+<use   name="RecoTracker/TransientTrackingRecHit"/>
+<use   name="TrackingTools/DetLayers"/>
+<use   name="TrackingTools/GeomPropagators"/>
+<use   name="TrackingTools/KalmanUpdators"/>
+<use   name="TrackingTools/MeasurementDet"/>
+<use   name="TrackingTools/PatternTools"/>
+<use   name="TrackingTools/TrajectoryState"/>
+<use   name="TrackingTools/TransientTrackingRecHit"/>
+<use   name="TrackingTools/TrackFitters"/>
+<export>
+  <lib   name="1"/>
+</export>
+

RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h

@@ -0,0 +1,85 @@
+#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);
+
+  virtual AlgebraicSymMatrix parametersError() const {
+    return HelpertRecHit2DLocalPos().parError( localPositionError(), *det()); 
+  }
+
+  //virtual ~GenericProjectedRecHit2D(){delete theOriginalTransientHit;}
+
+  virtual AlgebraicVector parameters() const ;
+
+  virtual LocalPoint localPosition() const {return theLp;}
+
+  virtual LocalError localPositionError() const {return theLe;}  
+
+  virtual AlgebraicMatrix projectionMatrix() const {return theProjectionMatrix;} 	
+
+  virtual DetId geographicalId() const {return det() ? det()->geographicalId() : DetId();}
+
+  virtual int dimension() const {return theDimension;}
+
+  //this hit lays on the original surface, NOT on the projection surface
+  virtual const TrackingRecHit * hit() const { return theOriginalTransientHit->hit(); }	
+
+  virtual TrackingRecHit * cloneHit() const { return theOriginalTransientHit->cloneHit(); }	
+
+  virtual bool isValid() const{return true;}
+
+  virtual std::vector<const TrackingRecHit*> recHits() const {
+  	//return theOriginalTransientHit->hit()->recHits();
+	return std::vector<const TrackingRecHit*>();
+  }
+
+  virtual std::vector<TrackingRecHit*> recHits() {
+	//should it do something different?
+        return std::vector<TrackingRecHit*>();
+  }
+
+  const TrackingRecHitPropagator* propagator() const {return thePropagator;}
+
+  virtual bool canImproveWithTrack() const {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; 
+
+  virtual GenericProjectedRecHit2D* clone() const {
+    return new GenericProjectedRecHit2D(*this);
+  }
+
+};
+
+
+
+#endif

RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h

@@ -0,0 +1,56 @@
+/** \class GroupedDAFHitCollector
+  *  Returns a collection of SiTrackerMultiRecHits and InvalidRecHits given a Trajectory.
+  *  Builds a SiTrackerMultiRecHit for each detGroup 
+  *  (i.e. a group of detectors mutually exclusive for the track's crossing point)
+  *
+  *  \author tropiano, genta
+  *  \review in May 2014 by brondolin 
+  */
+
+#ifndef SiTrackerMRHTools_GroupedDAFHitCollector_h
+#define SiTrackerMRHTools_GroupedDAFHitCollector_h
+
+#include "TrackingTools/MeasurementDet/interface/LayerMeasurements.h"
+#include "RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h"
+#include <vector>
+
+class Propagator;
+class MeasurementEstimator;
+class MeasurementTracker;
+class SiTrackerMultiRecHitUpdator;
+
+class GroupedDAFHitCollector :public MultiRecHitCollector {
+
+public:
+	explicit GroupedDAFHitCollector(const MeasurementTracker* measurementTracker,
+				 const SiTrackerMultiRecHitUpdator* updator,
+			         const MeasurementEstimator* est,
+				 const Propagator* propagator,
+				 const Propagator* reversePropagator, bool debug):
+		MultiRecHitCollector(measurementTracker), theUpdator(updator), 
+		theEstimator(est), thePropagator(propagator), theReversePropagator(reversePropagator), debug_(debug){}
+
+
+	virtual ~GroupedDAFHitCollector(){}
+
+	virtual std::vector<TrajectoryMeasurement> recHits(const Trajectory&, 
+							   const MeasurementTrackerEvent *theMT) const;
+
+	const SiTrackerMultiRecHitUpdator* getUpdator() const {return theUpdator;}
+	const MeasurementEstimator* getEstimator() const {return theEstimator;}
+        const Propagator* getPropagator() const {return thePropagator;}
+        const Propagator* getReversePropagator() const {return theReversePropagator;}
+
+private:
+	void buildMultiRecHits(const std::vector<TrajectoryMeasurementGroup>& measgroup, 
+			       std::vector<TrajectoryMeasurement>& result) const;
+
+	const SiTrackerMultiRecHitUpdator* theUpdator;
+	const MeasurementEstimator* theEstimator;
+	const Propagator* thePropagator;
+	const Propagator* theReversePropagator;
+	const bool debug_;
+};
+
+
+#endif 

RecoTracker/SiTrackerMRHTools/interface/MeasurementByLayerGrouper.h

@@ -0,0 +1,39 @@
+#ifndef SiTrackerMRHTools_MeasurementByLayerGrouper_H
+#define SiTrackerMRHTools_MeasurementByLayerGrouper_H
+
+class DetLayer;
+class TrajectoryMeasurement;
+class GeometricSearchTracker;
+
+#include <vector>
+#include <map>
+
+//groups the TrajectoryMeasurements on a layer by layer basis
+
+class MeasurementByLayerGrouper {
+
+private:
+
+  typedef TrajectoryMeasurement TM;
+  const GeometricSearchTracker* theGeomSearch; 
+
+  const DetLayer* getDetLayer(const TM& tm) const;
+
+public:
+
+  explicit MeasurementByLayerGrouper(const GeometricSearchTracker* search = 0):theGeomSearch(search){};
+
+  std::vector<std::pair<const DetLayer*, std::vector<TM> > > operator()(const std::vector<TM>&) const;
+
+
+//to be ported later if needed
+/*
+  vector<TM> 
+  operator()(const vector<pair<const DetLayer*, vector<TM> > >&) const;
+
+  vector<pair<const DetLayer*, map<int, vector<TrajectoryMeasurement> > > > 
+  operator()(const map<int, vector<TM> >&) const;
+*/
+
+};
+#endif

RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h

@@ -0,0 +1,26 @@
+#ifndef SiTrackerMRHTools_MultiRecHitCollector_h
+#define SiTrackerMRHTools_MultiRecHitCollector_h
+
+#include "RecoTracker/MeasurementDet/interface/MeasurementTracker.h"
+#include <vector>
+
+class Trajectory;
+class TrajectoryMeasurement;
+
+class MultiRecHitCollector {
+
+	public:
+	MultiRecHitCollector(const MeasurementTracker* meas): theMeasurementTracker(meas){}
+
+	virtual std::vector<TrajectoryMeasurement> recHits(const Trajectory&, const MeasurementTrackerEvent *theMTE) const = 0;
+
+	const MeasurementTracker* getMeasurementTracker() const {return theMeasurementTracker;}
+
+
+	private:
+	const MeasurementTracker* theMeasurementTracker;		
+
+};
+
+#endif
+