PFBlockElement.h

Go to the documentation of this file.

#ifndef __PFBlockElement__
#define __PFBlockElement__
 
#include "DataFormats/ParticleFlowReco/interface/PFRecTrackFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedTrackerVertex.h"
#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/EgammaCandidates/interface/Conversion.h"
#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"
#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h"
#include "DataFormats/Candidate/interface/VertexCompositeCandidateFwd.h"
 
#include "DataFormats/ParticleFlowReco/interface/PFMultilinksTC.h"  // Glowinski & Gouzevitch
 
#include <iostream>
 
namespace reco {
  class PFBlockElementCluster;
  class PFBlockElementTrack;
 
  class PFBlockElement {
  public:
    enum Type {
      NONE = 0,
      TRACK = 1,
      PS1 = 2,
      PS2 = 3,
      ECAL = 4,
      HCAL = 5,
      GSF = 6,
      BREM = 7,
      HFEM = 8,
      HFHAD = 9,
      SC = 10,
      HO = 11,
      HGCAL = 12,
      kNBETypes = 13
    };
 
    enum TrackType { DEFAULT = 0, T_FROM_DISP, T_TO_DISP, T_FROM_GAMMACONV, MUON, T_FROM_V0 };
 
    PFBlockElement(Type type = NONE)
        : type_(type), locked_(false), index_(static_cast<unsigned>(-1)), time_(0.f), timeError_(-1.f) {}
 
    virtual ~PFBlockElement() {}
 
    virtual void Dump(std::ostream& out = std::cout, const char* tab = " ") const;
 
    virtual PFBlockElement* clone() const = 0;
 
    void lock() { locked_ = true; }
 
    void unLock() { locked_ = false; }
 
    Type type() const { return type_; }
 
    virtual bool trackType(TrackType trType) const { return false; }
 
    virtual void setTrackType(TrackType trType, bool value) {
      std::cout << "Error in PFBlockElement::setTrackType : this base class method is not implemented" << std::endl;
    }
 
    bool locked() const { return locked_; }
 
    void setIndex(unsigned index) { index_ = index; }
 
    unsigned index() const { return index_; }
 
    virtual const reco::TrackRef& trackRef() const { return nullTrack_; }
    virtual const PFRecTrackRef& trackRefPF() const { return nullPFRecTrack_; }
    virtual const PFClusterRef& clusterRef() const { return nullPFCluster_; }
    virtual const PFDisplacedTrackerVertexRef& displacedVertexRef(TrackType trType) const { return nullPFDispVertex_; }
    virtual const ConversionRefVector& convRefs() const { return nullConv_; }
    virtual const MuonRef& muonRef() const { return nullMuon_; }
    virtual const VertexCompositeCandidateRef& V0Ref() const { return nullVertex_; }
    virtual void setDisplacedVertexRef(const PFDisplacedTrackerVertexRef& niref, TrackType trType) {
      std::cout << "Error in PFBlockElement::setDisplacedVertexRef : this base class method is not implemented"
                << std::endl;
    }
    virtual void setConversionRef(const ConversionRef& convRef, TrackType trType) {
      std::cout << "Error in PFBlockElement::setConversionRef : this base class method is not implemented" << std::endl;
    }
    virtual void setMuonRef(const MuonRef& muref) {
      std::cout << "Error in PFBlockElement::setMuonRef : this base class method is not implemented" << std::endl;
    }
    virtual void setV0Ref(const VertexCompositeCandidateRef& v0ref, TrackType trType) {
      std::cout << "Error in PFBlockElement::setV0Ref : this base class method is not implemented" << std::endl;
    }
 
    virtual bool isSecondary() const { return false; }
    virtual bool isPrimary() const { return false; }
    virtual bool isLinkedToDisplacedVertex() const { return false; }
 
    // Glowinski & Gouzevitch
    void setMultilinks(const PFMultiLinksTC& ml, Type type) { multilinks_[type] = ml; }
    void setIsValidMultilinks(bool isVal, Type type) { multilinks_[type].isValid = isVal; }
 
    bool isMultilinksValide(Type type) const {
      const auto& it = multilinks_.find(type);
      if (it != multilinks_.end())
        return it->second.isValid;
      else
        return false;  // no multilinks_ for the specified type
    }
    const PFMultilinksType& getMultilinks(Type type) const { return multilinks_.at(type).linkedClusters; }
    // ! Glowinski & Gouzevitch
 
    bool isTimeValid() const { return timeError_ >= 0.f; }
    float time() const { return time_; }
    float timeError() const { return timeError_; }
    void setTime(float time, float timeError = 0.f) {
      time_ = time;
      timeError_ = timeError;
    }
 
  protected:
    Type type_;
 
    bool locked_;
 
    unsigned index_;
 
    // Glowinski & Gouzevitch
    // PFMultiLinks for each different link target type
    std::map<reco::PFBlockElement::Type, PFMultiLinksTC> multilinks_;
    // ! Glowinski & Gouzevitch
 
    float time_;
    float timeError_;
 
    const static reco::TrackRef nullTrack_;
    const static PFRecTrackRef nullPFRecTrack_;
    const static PFClusterRef nullPFCluster_;
    const static PFDisplacedTrackerVertexRef nullPFDispVertex_;
    const static ConversionRefVector nullConv_;
    const static MuonRef nullMuon_;
    const static VertexCompositeCandidateRef nullVertex_;
  };
 
  std::ostream& operator<<(std::ostream& out, const PFBlockElement& element);
 
}  // namespace reco
#endif