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).linkedPFObjects; }
    // ! 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