FastTrackerRecHit.h

Go to the documentation of this file.

#ifndef FastTrackerRecHit_H
#define FastTrackerRecHit_H

#include "DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h"
#include "stdint.h"

namespace fastTrackerRecHitType {
    enum HitType {
    siPixel = 0,
    siStrip1D = 1,
    siStrip2D = 2,
    siStripMatched2D = 3,
    siStripProjectedMono2D = 4,
    siStripProjectedStereo2D = 5,
    };
    inline trackerHitRTTI::RTTI rtti(HitType hitType){
    if(hitType >=0 && hitType <= 2) return trackerHitRTTI::fastSingle;
    else if(hitType == siStripMatched2D) return trackerHitRTTI::fastMatch;
    else if(hitType == siStripProjectedMono2D) return trackerHitRTTI::fastProjMono;
    else if(hitType == siStripProjectedStereo2D) return trackerHitRTTI::fastProjStereo;
    else return trackerHitRTTI::undef;
    }
    inline bool is2D(HitType hitType) {return hitType != siStrip1D;}
    inline bool isPixel(HitType hitType) {return hitType == siPixel;}
}


class FastTrackerRecHit : public BaseTrackerRecHit 
{
    public:

    FastTrackerRecHit()
    : BaseTrackerRecHit()
    , isPixel_(false)
    , is2D_(true)
    , recHitCombinationIndex_(-1)
    {}
    
    ~FastTrackerRecHit() {}
    
    FastTrackerRecHit( const LocalPoint& p, const LocalError&e, GeomDet const & idet,fastTrackerRecHitType::HitType hitType) 
    : BaseTrackerRecHit(p,e,idet,fastTrackerRecHitType::rtti(hitType)) 
    , isPixel_(fastTrackerRecHitType::isPixel(hitType))
    , is2D_(fastTrackerRecHitType::is2D(hitType))
    , recHitCombinationIndex_(-1)
    {store();}

    virtual FastTrackerRecHit * clone() const override {FastTrackerRecHit * p =  new FastTrackerRecHit( * this); p->load(); return p;}

    void getKfComponents( KfComponentsHolder & holder ) const override { if(is2D_) getKfComponents2D(holder); else getKfComponents1D(holder);}

    int dimension() const override {return is2D_ ? 2 : 1;} 

    virtual bool canImproveWithTrack() const override {return false;}

    /* getters */

    virtual size_t               nIds()                        const { return 0;}
    virtual int32_t              id(size_t i = 0)              const { return -1;}
    virtual int32_t              eventId(size_t i = 0)         const { return -1;}
    
    virtual size_t               nSimTrackIds()                const { return 0;}
    virtual int32_t              simTrackId(size_t i)          const { return -1;}
    virtual int32_t              simTrackEventId(size_t i)     const { return -1;}

    virtual int32_t              recHitCombinationIndex() const { return recHitCombinationIndex_;}

    bool isPixel() const override {return isPixel_;} 

    /* setters */

    virtual void setEventId(int32_t eventId) {};

    void set2D(bool is2D=true){is2D_ = is2D;}

    virtual void setRecHitCombinationIndex(int32_t recHitCombinationIndex) {recHitCombinationIndex_ = recHitCombinationIndex;}

    virtual std::vector<const TrackingRecHit*> recHits() const override { return std::vector<TrackingRecHit const*>();}

    virtual std::vector<TrackingRecHit*> recHits() override { return std::vector<TrackingRecHit*>();}
 
    OmniClusterRef const & firstClusterRef() const override;

    // used by functions
    // - FastTrackerSingleRecHit::sharesInput 
    // - FastSiStripMatchedRecHit::sharesInput
    // - FastProjectedSiStripRecHit2D::sharesInput
    inline bool sameId(const FastTrackerRecHit * other,size_t i=0,size_t j = 0) const {return id(i) == other->id(j) && eventId(i) == other->eventId(j);}
    inline bool sharesInput(const TrackingRecHit * other,SharedInputType what) const override {

    // cast other hit
    if(!trackerHitRTTI::isFast(*other) )
        return false;
    const FastTrackerRecHit * otherCast = static_cast<const FastTrackerRecHit *>(other);
    
    // checks
    if(this->nIds() == 1){           // this hit is single/projected
        if(otherCast->nIds() == 1){  // other hit is single/projected
        return this->sameId(otherCast,0,0);
        }
        else {                       // other hit is matched
        if(what == all){
            return false;
        }
        else {
            return(this->sameId(otherCast,0,0) || this->sameId(otherCast,0,1));
        }
        }
    }
    else{                            // this hit is matched
        if(otherCast->nIds() == 1){  // other hit is single/projected
        if (what == all){
            return false;
        }
        else{
            return(this->sameId(otherCast,0,0) || this->sameId(otherCast,1,0));
        }
        }
        else{                        // other hit is matched
        if(what == all){
            return(this->sameId(otherCast,0,0) && this->sameId(otherCast,1,1));
        }
        else {
            return(this->sameId(otherCast,0,0) || this->sameId(otherCast,1,1));
        }
        }
    }
    }

    protected:

    const bool isPixel_;                 
    bool is2D_;                          
    
    LocalPoint myPos_;                   
    LocalError myErr_;                   

    void store() { myPos_=pos_;  myErr_=err_;}  
    void load()  { pos_=myPos_; err_=myErr_;}   
    
    uint32_t recHitCombinationIndex_;

    protected:

    virtual FastTrackerRecHit * clone(TkCloner const& cloner, TrajectoryStateOnSurface const& tsos) const override {
    return this->clone();
    }
  
};

inline bool operator<( const FastTrackerRecHit& one, const FastTrackerRecHit& other) {
    return ( one.geographicalId() < other.geographicalId() );
}

#endif