PFBlockElementTrack.h

Go to the documentation of this file.

#ifndef __PFBlockElementTrack__
#define __PFBlockElementTrack__

#include <iostream>

#include "DataFormats/Math/interface/Point3D.h"

#include "DataFormats/ParticleFlowReco/interface/PFBlockElement.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecTrackFwd.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"

namespace reco {
  
  class PFBlockElementTrack : public PFBlockElement {
  public:

    PFBlockElementTrack() {} 

    PFBlockElementTrack(const PFRecTrackRef& ref);

    PFBlockElement* clone() const override { return new PFBlockElementTrack(*this); }
    
    void Dump(std::ostream& out = std::cout, 
              const char* tab = " " ) const override;

    bool trackType(TrackType trType) const override { 
      return (trackType_>>trType) & 1; 
    }

    void setTrackType(TrackType trType, bool value) override {
      if(value)  trackType_ = trackType_ | (1<<trType);
      else trackType_ = trackType_ ^ (1<<trType);
    }


    void setPositionAtECALEntrance(float x, float y, float z) {
      positionAtECALEntrance_.SetCoordinates(x, y, z);
    }
 

    const math::XYZPointF& positionAtECALEntrance() const {
      return positionAtECALEntrance_;
    }
    
    const PFRecTrackRef& trackRefPF() const override { return trackRefPF_; }
    
    const reco::TrackRef& trackRef() const override { return trackRef_; }

    bool isSecondary() const override { 
      return 
    trackType(T_FROM_DISP) || 
    trackType(T_FROM_GAMMACONV) || 
    trackType(T_FROM_V0); 
    }

    bool isPrimary() const override{
      return trackType(T_TO_DISP); 
    }

    bool isLinkedToDisplacedVertex() const override{
      return isSecondary() || isPrimary();
    }

    const PFDisplacedTrackerVertexRef& 
      displacedVertexRef(TrackType trType) const override {
      if (trType == T_TO_DISP)
    return displacedVertexDaughterRef_;
      else if (trType == T_FROM_DISP)
    return displacedVertexMotherRef_;
      else return nullPFDispVertex_;
    }

    void setDisplacedVertexRef(const PFDisplacedTrackerVertexRef& niref, TrackType trType) override { 

      if (trType == T_TO_DISP) {
    displacedVertexDaughterRef_ = niref; setTrackType(trType,true);}
      else if (trType == T_FROM_DISP) {
        displacedVertexMotherRef_ = niref; setTrackType(trType,true);}
    } 
    
    const reco::MuonRef& muonRef() const override { return muonRef_; }

    void setMuonRef(const MuonRef& muref) override { 
      muonRef_=muref; setTrackType(MUON,true); 
    }

    const ConversionRefVector& convRefs() const override {return convRefs_;} 

    void setConversionRef(const ConversionRef& convRef, TrackType trType) override { 
      convRefs_.push_back(convRef); setTrackType(trType,true); 
    } 

    const VertexCompositeCandidateRef& V0Ref() const override {return v0Ref_;} 

    void setV0Ref(const VertexCompositeCandidateRef& V0Ref, TrackType trType) override { 
      v0Ref_ = V0Ref; setTrackType(trType,true); 
    } 


    
  private:

    PFRecTrackRef  trackRefPF_;

    reco::TrackRef trackRef_;

    unsigned int  trackType_;

    math::XYZPointF        positionAtECALEntrance_;
    
    PFDisplacedTrackerVertexRef  displacedVertexMotherRef_;

    PFDisplacedTrackerVertexRef  displacedVertexDaughterRef_;
                                 
    reco::MuonRef muonRef_;

    ConversionRefVector convRefs_;      

    VertexCompositeCandidateRef v0Ref_;
  };
}

#endif