Fastsim newrechits rebase sep4

CommonTools/RecoAlgos/src/ClusterStorer.cc

@@ -9,8 +9,9 @@
 #include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h"
 #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h"
 // FastSim hits:
-#include "DataFormats/TrackerRecHit2D/interface/SiTrackerGSRecHit2D.h"
-#include "DataFormats/TrackerRecHit2D/interface/SiTrackerGSMatchedRecHit2D.h"
+#include "DataFormats/TrackerRecHit2D/interface/FastTrackerRecHit.h"
+#include "DataFormats/TrackerRecHit2D/interface/FastProjectedTrackerRecHit.h"
+#include "DataFormats/TrackerRecHit2D/interface/FastMatchedTrackerRecHit.h"
 
 
 #include "DataFormats/SiStripDetId/interface/SiStripDetId.h"
@@ -45,8 +46,9 @@ namespace helper {
       ProjectedSiStripRecHit2D &phit = static_cast<ProjectedSiStripRecHit2D&>(newHit);
       stripClusterRecords_.push_back(StripClusterHitRecord(phit.originalHit(), hits, index));
     } else {
-      if (hit_type == typeid(SiTrackerGSMatchedRecHit2D)
- 	  || hit_type == typeid(SiTrackerGSRecHit2D)) {
+      if (hit_type == typeid(FastTrackerRecHit)
+ 	  || hit_type == typeid(FastProjectedTrackerRecHit)
+	  || hit_type == typeid(FastMatchedTrackerRecHit)) {
 	//std::cout << "|   It is a " << hit_type.name() << " hit !!" << std::endl;
 	// FastSim hits: Do nothing instead of caring about FastSim clusters, 
 	//               not even sure whether these really exist.

DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h

@@ -15,18 +15,18 @@ class OmniClusterRef;
 
 namespace trackerHitRTTI {
   // tracking hit can be : single (si1D, si2D, pix), projected, matched or multi
-  enum RTTI { undef=0, single=1, projStereo=2, projMono=3, match=4, multi=5, gs=6, gsMatch=7};
+  enum RTTI { undef=0, single=1, projStereo=2, projMono=3, match=4, multi=5,
+	      fastSingle=6, fastProjStereo=7,fastProjMono=8,fastMatch=9};
   inline RTTI rtti(TrackingRecHit const & hit)  { return RTTI(hit.getRTTI());}
   inline bool isUndef(TrackingRecHit const & hit) { return rtti(hit)==undef;}
-  inline bool isSingle(TrackingRecHit const & hit)  { return rtti(hit)==single;}
-  inline bool isProjMono(TrackingRecHit const & hit)  { return rtti(hit)==projMono;}
-  inline bool isProjStereo(TrackingRecHit const & hit)  { return rtti(hit)==projStereo;}
-  inline bool isProjected(TrackingRecHit const & hit)  { return (rtti(hit)==projMono) | (rtti(hit)==projStereo);}
-  inline bool isMatched(TrackingRecHit const & hit)  { return rtti(hit)==match;}
+  inline bool isSingle(TrackingRecHit const & hit)  { return rtti(hit)==single || rtti(hit)==fastSingle;}
+  inline bool isProjMono(TrackingRecHit const & hit)  { return rtti(hit)==projMono || rtti(hit)==fastProjMono;}
+  inline bool isProjStereo(TrackingRecHit const & hit)  { return rtti(hit)==projStereo || fastProjStereo;}
+  inline bool isProjected(TrackingRecHit const & hit)  { return ((rtti(hit)==projMono) | (rtti(hit)==projStereo)) || (rtti(hit)==fastProjMono) | (rtti(hit)==fastProjStereo);}
+  inline bool isMatched(TrackingRecHit const & hit)  { return rtti(hit)==match || rtti(hit)==fastMatch;}
   inline bool isMulti(TrackingRecHit const & hit)  { return rtti(hit)==multi;}
-  inline bool isGS(TrackingRecHit const & hit)  { return rtti(hit)==gs;}
   inline bool isSingleType(TrackingRecHit const & hit)  { return (rtti(hit)>0) & (rtti(hit)<4) ;}
-
+  inline bool isFast(TrackingRecHit const & hit)  { return (rtti(hit)>5) & (rtti(hit)<=9) ;}
   inline unsigned int  projId(TrackingRecHit const & hit) { return hit.rawId()+int(rtti(hit))-1;}
 }
 

DataFormats/TrackerRecHit2D/interface/FastMatchedTrackerRecHit.h

@@ -0,0 +1,61 @@
+#ifndef FastMatchedTrackerRecHit_H
+#define FastMatchedTrackerRecHit_H
+
+#include "DataFormats/TrackerRecHit2D/interface/FastTrackerRecHit.h"
+#include "DataFormats/TrackerRecHit2D/interface/FastSingleTrackerRecHit.h"
+
+class FastMatchedTrackerRecHit : public FastTrackerRecHit{
+
+    public:
+
+    FastMatchedTrackerRecHit()
+	: stereoHitFirst_(false)
+	{}
+
+    ~FastMatchedTrackerRecHit() {}
+
+    FastMatchedTrackerRecHit( const LocalPoint & pos, 
+			      const LocalError & err,
+			      const GeomDet & idet,
+			      const FastSingleTrackerRecHit & rMono, 
+			      const FastSingleTrackerRecHit & rStereo,
+			      bool stereoHitFirst = false) 
+	: FastTrackerRecHit(pos,err,idet,fastTrackerRecHitType::siStripMatched2D)
+	, stereoHitFirst_(stereoHitFirst)
+	, componentMono_(rMono) 
+	, componentStereo_(rStereo)
+    {};
+
+    virtual FastMatchedTrackerRecHit * clone() const {FastMatchedTrackerRecHit * p =  new FastMatchedTrackerRecHit( * this); p->load(); return p;}
+
+    size_t    nIds()                    const { return 2;}
+    int32_t   id(size_t i = 0)          const { return i==0 ? monoHit().id() : stereoHit().id(); }
+    int32_t   eventId(size_t i = 0)     const { return i==0 ? monoHit().eventId() : stereoHit().eventId(); }
+
+    size_t    nSimTrackIds()            const { return componentMono_.nSimTrackIds() + componentStereo_.nSimTrackIds();}                             ///< see addSimTrackId(int32_t simTrackId)
+    int32_t   simTrackId(size_t i)      const { return i < componentMono_.nSimTrackIds() ? componentMono_.simTrackId(i) : componentStereo_.simTrackId(i-componentMono_.nSimTrackIds()); }
+    int32_t   simTrackEventId(size_t i) const { return i < componentMono_.nSimTrackIds() ? componentMono_.simTrackEventId(i) : componentStereo_.simTrackEventId(i-componentMono_.nSimTrackIds()); }
+
+    const FastSingleTrackerRecHit &   monoHit()                const { return componentMono_;}
+    const FastSingleTrackerRecHit &   stereoHit()              const { return componentStereo_;}
+    const FastSingleTrackerRecHit &   firstHit()               const { return stereoHitFirst_ ? componentStereo_ : componentMono_;}
+    const FastSingleTrackerRecHit &   secondHit()              const { return stereoHitFirst_ ? componentMono_ : componentStereo_;}
+
+
+    void setStereoLayerFirst(bool stereoHitFirst = true){stereoHitFirst_ = stereoHitFirst;}
+    void setEventId(int32_t eventId){componentMono_.setEventId(eventId);componentStereo_.setEventId(eventId);}
+
+    void setRecHitCombinationIndex(int32_t recHitCombinationIndex) {
+	FastTrackerRecHit::setRecHitCombinationIndex(recHitCombinationIndex);
+	componentMono_.setRecHitCombinationIndex(recHitCombinationIndex);
+	componentStereo_.setRecHitCombinationIndex(recHitCombinationIndex);
+    }
+
+    private:
+
+    bool stereoHitFirst_;
+    FastSingleTrackerRecHit componentMono_;
+    FastSingleTrackerRecHit componentStereo_;
+};
+
+#endif

DataFormats/TrackerRecHit2D/interface/FastProjectedTrackerRecHit.h

@@ -0,0 +1,49 @@
+#ifndef FastProjectedTrackerRecHit_H
+#define FastProjectedTrackerRecHit_H
+
+#include "DataFormats/TrackerRecHit2D/interface/FastTrackerRecHit.h"
+#include "DataFormats/TrackerRecHit2D/interface/FastSingleTrackerRecHit.h"
+#include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h"
+
+class FastProjectedTrackerRecHit : public FastTrackerRecHit {
+
+    public :
+
+    FastProjectedTrackerRecHit() {};
+
+    ~FastProjectedTrackerRecHit() {};
+
+    FastProjectedTrackerRecHit( const LocalPoint& pos, 
+				const LocalError& err, 
+				GeomDet const & idet,
+				FastSingleTrackerRecHit const & originalHit) 
+	: FastTrackerRecHit(pos, err, idet, 
+			    ProjectedSiStripRecHit2D::isMono(idet,*originalHit.det()) 
+			    ? fastTrackerRecHitType::siStripProjectedMono2D 
+			    : fastTrackerRecHitType::siStripProjectedStereo2D )
+	, originalHit_(originalHit)
+    {}
+
+    const FastSingleTrackerRecHit & originalHit() const {return originalHit_;}
+    virtual FastProjectedTrackerRecHit * clone() const {FastProjectedTrackerRecHit * p =  new FastProjectedTrackerRecHit( * this); p->load(); return p;}
+    size_t                       nIds()                    const { return 1;}
+    int32_t                      id(size_t i = 0)          const { return originalHit().id(i);}
+    int32_t                      eventId(size_t i = 0)     const { return originalHit().eventId(i);}
+    size_t                       nSimTrackIds()            const { return originalHit_.nSimTrackIds();}                             ///< see addSimTrackId(int32_t simTrackId)
+    int32_t                      simTrackId(size_t i)      const { return originalHit_.simTrackId(i);}                              ///< see addSimTrackId(int32_t simTrackId)
+    int32_t                      simTrackEventId(size_t i) const { return originalHit_.simTrackEventId(i);;}                        ///< see addSimTrackId(int32_t simTrackId)
+
+    void setEventId(int32_t eventId){originalHit_.setEventId(eventId);}
+
+    void setRecHitCombinationIndex(int32_t recHitCombinationIndex) {
+	FastTrackerRecHit::setRecHitCombinationIndex(recHitCombinationIndex);
+	originalHit_.setRecHitCombinationIndex(recHitCombinationIndex);
+    }
+
+    private:
+
+    FastSingleTrackerRecHit originalHit_;
+
+};
+
+#endif

DataFormats/TrackerRecHit2D/interface/FastSingleTrackerRecHit.h

@@ -0,0 +1,56 @@
+#ifndef FastSingleTrackerRecHit_H
+#define FastSingleTrackerRecHit_H
+
+#include "DataFormats/TrackerRecHit2D/interface/FastTrackerRecHit.h"
+#include "stdint.h"
+
+class FastSingleTrackerRecHit : public FastTrackerRecHit {
+
+    public:
+
+    FastSingleTrackerRecHit ()
+	: FastTrackerRecHit()
+	, id_(-1)
+	, eventId_(0) {}
+
+
+    FastSingleTrackerRecHit (const LocalPoint& p, const LocalError&e, GeomDet const & idet,fastTrackerRecHitType::HitType hitType)
+	: FastTrackerRecHit(p,e,idet,hitType)
+	, id_(-1)
+	, eventId_(0) {}
+
+    public:
+
+    virtual FastSingleTrackerRecHit * clone() const GCC11_OVERRIDE  {FastSingleTrackerRecHit * p =  new FastSingleTrackerRecHit( * this); p->load(); return p;}
+
+    size_t                       nIds()                    const { return 1;}
+    int32_t                      id(size_t i =0)           const { return i == 0 ? id_ : -1;}
+    int32_t                      eventId(size_t i = 0)     const { return i == 0 ? eventId_ : -1;}
+    size_t                       nSimTrackIds()            const { return simTrackIds_.size();}                             ///< see addSimTrackId(int32_t simTrackId)
+    int32_t                      simTrackId(size_t i)      const { return i < simTrackIds_.size() ? simTrackIds_[i] : -1;}  ///< see addSimTrackId(int32_t simTrackId)
+    int32_t                      simTrackEventId(size_t i) const { return i < simTrackIds_.size() ? eventId_ : -1;}  ///< see addSimTrackId(int32_t simTrackId)
+
+
+    /// add an id number to the list of id numbers of SimTracks from which the hit originates
+    /// the SimTrack id numbers are the indices of the SimTracks in the SimTrack collection
+    void addSimTrackId(int32_t simTrackId)  {simTrackIds_.push_back(simTrackId);}
+
+    /// set the hit id number
+    /// for any particular hit in any particular event,
+    // the hit id number must be unique within the list of hits in the event
+    void setId(int32_t id)            {id_ = id;}
+
+    /// set the hit's event number
+    /// there is in principle no reason to play with this variable outside the PU mixing modules
+    /// see Adjuster::doTheOffset(int bunchSpace, int bcr, TrackingRecHitCollection & trackingrechits, unsigned int evtNr, int vertexOffset)
+    void setEventId(int32_t eventId)    {eventId_ = eventId;}
+
+    private:
+
+    int32_t id_;                                             ///< see setId(int32_t id)
+    int32_t eventId_;                                        ///< see setEeId(int32_t eeid)
+    std::vector<int32_t> simTrackIds_;                       ///< see addSimTrackIds(int32_t)
+
+};
+
+#endif