TrackingRecHit.h

Go to the documentation of this file.

#ifndef TrackingRecHit_h
#define TrackingRecHit_h

#include "DataFormats/CLHEP/interface/AlgebraicObjects.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/GeometrySurface/interface/LocalError.h"
#include "DataFormats/GeometryVector/interface/LocalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/GlobalError.h"
#include "Geometry/CommonDetUnit/interface/GeomDet.h"
#include "DataFormats/GeometrySurface/interface/Surface.h" 


#include "FWCore/Utilities/interface/GCC11Compatibility.h"
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
#define NO_DICT
#endif

#include<vector>
#include<memory>

class TkCloner;
class TrajectoryStateOnSurface;
class KfComponentsHolder;

class TrackingRecHit {
public:

#ifdef NO_DICT
   using      RecHitPointer = std::shared_ptr<TrackingRecHit const>;  // requires to much editing
   using ConstRecHitPointer = std::shared_ptr<TrackingRecHit const>;   
#else
   typedef TrackingRecHit const *          RecHitPointer;
   typedef TrackingRecHit const *     ConstRecHitPointer;
#endif

  typedef std::vector<ConstRecHitPointer>                           RecHitContainer;
  typedef std::vector<ConstRecHitPointer>                           ConstRecHitContainer;



  friend class MuonTransientTrackingRecHit;

  typedef unsigned int id_type;
  
  enum Type { valid = 0, missing = 1, inactive = 2, bad = 3, missing_inner = 4, missing_outer = 5};
  static const int typeMask = 0xf;  // mask for the above
  static const int rttiShift = 24; // shift amount to get the rtti
 
  enum SharedInputType {all, some};
  
  explicit TrackingRecHit(DetId id, Type type=valid ) : m_id(id), m_status(type),  m_det(nullptr) {}
  explicit TrackingRecHit(id_type id=0, Type type=valid ) : m_id(id), m_status(type), m_det(nullptr) {}
  TrackingRecHit(DetId id,  unsigned int rt, Type type=valid  ) : m_id(id), m_status((rt<< rttiShift)|int(type)),  m_det(nullptr){}


  explicit TrackingRecHit(const GeomDet & idet, Type type=valid) : m_id(idet.geographicalId()), m_status(type), m_det(&idet){}
  TrackingRecHit(const GeomDet & idet,  unsigned int rt, Type type=valid  ) : m_id(idet.geographicalId()), m_status((rt<< rttiShift)|int(type)),  m_det(&idet){}
  TrackingRecHit(const GeomDet & idet,  TrackingRecHit const & rh) : m_id(rh.m_id), m_status(rh.m_status), m_det(&idet){} 


  virtual ~TrackingRecHit() {}

  // fake TTRH interface
  virtual TrackingRecHit const * hit() const { return this;}  
  virtual TrackingRecHit * cloneHit() const { return clone();}

  
  virtual TrackingRecHit * clone() const = 0;
#ifdef NO_DICT
  virtual RecHitPointer cloneSH() const { return RecHitPointer(clone());}
  // clone and add the geom (ready for refit)
  RecHitPointer cloneForFit(const GeomDet & idet) const {
    auto cl = cloneSH();
    const_cast<TrackingRecHit&>(*cl).setDet(idet); // const_cast (can be fixed editing some 100 files)
    return cl;  
  }
#endif
  virtual void setDet(const GeomDet & idet) {m_det = &idet;}

  
  virtual AlgebraicVector parameters() const = 0;
  
  virtual AlgebraicSymMatrix parametersError() const = 0;
  
  virtual AlgebraicMatrix projectionMatrix() const = 0;

  virtual void getKfComponents( KfComponentsHolder & holder ) const ; 
 
  virtual int dimension() const = 0;
  
  virtual std::vector<const TrackingRecHit*> recHits() const = 0;
  virtual void recHitsV(std::vector<const TrackingRecHit*> & ) const;
  
  virtual std::vector<TrackingRecHit*> recHits() = 0;
  virtual void recHitsV(std::vector<TrackingRecHit*> & );

#ifdef NO_DICT
  virtual ConstRecHitContainer transientHits() const {
    ConstRecHitContainer result;
    std::vector<const TrackingRecHit*> hits;
    recHitsV(hits);
    for (auto h : hits) result.push_back(h->cloneSH());
    return result;
  }
#endif

  id_type rawId() const { return m_id;}
  DetId geographicalId() const {return m_id;}

  const GeomDet * det() const { return m_det;}
  virtual const Surface * surface() const {return &(det()->surface());}


  virtual const GeomDetUnit * detUnit() const;
  

  virtual LocalPoint localPosition() const = 0;
  
  virtual LocalError localPositionError() const = 0;

  virtual bool hasPositionAndError() const {return true;}; 
  
  virtual float weight() const {return 1.;}
  
  Type type() const { return Type(typeMask&m_status); }
  Type getType() const { return Type(typeMask&m_status); }
  bool isValid() const {return getType()==valid;}
  
  unsigned int getRTTI() const { return m_status >> rttiShift;}

  virtual bool sharesInput( const TrackingRecHit* other, SharedInputType what) const;


  //  global coordinates
  
  virtual GlobalPoint globalPosition() const;
  virtual GlobalError globalPositionError() const;
  
  virtual float errorGlobalR() const;
  virtual float errorGlobalZ() const;
  virtual float errorGlobalRPhi() const;


  virtual bool canImproveWithTrack() const {return false;}
private:
  friend class  TkCloner;
  // double dispatch
  virtual TrackingRecHit * clone(TkCloner const&, TrajectoryStateOnSurface const&) const {
    assert("clone"==nullptr);
    return clone(); // default
  }
#ifdef NO_DICT
  virtual  RecHitPointer cloneSH(TkCloner const&, TrajectoryStateOnSurface const&) const {
    assert("cloneSH"==nullptr);
    return cloneSH(); // default
  }
#endif

protected:
  // used by muon...
  void setId(id_type iid) { m_id=iid;}
  void setType(Type ttype) { m_status=ttype;}
  
  void setRTTI (unsigned int rt) { m_status &= (rt<< rttiShift);} // can be done only once...

private:
  
  id_type m_id;

  unsigned int m_status; // bit assigned (type 0-8) (rtti 24-31) 

  const GeomDet * m_det;

};

#endif