Electron.cc

Go to the documentation of this file.

//
//

#include "DataFormats/PatCandidates/interface/Electron.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "DataFormats/Common/interface/RefToPtr.h"

#include <limits>

using namespace pat;

Electron::Electron()
    : Lepton<reco::GsfElectron>(),
      embeddedGsfElectronCore_(false),
      embeddedGsfTrack_(false),
      embeddedSuperCluster_(false),
      embeddedPflowSuperCluster_(false),
      embeddedTrack_(false),
      embeddedSeedCluster_(false),
      embeddedRecHits_(false),
      embeddedPFCandidate_(false),
      ecalDrivenMomentum_(Candidate::LorentzVector(0., 0., 0., 0.)),
      ecalRegressionEnergy_(0.0),
      ecalTrackRegressionEnergy_(0.0),
      ecalRegressionError_(0.0),
      ecalTrackRegressionError_(0.0),
      ecalScale_(-99999.),
      ecalSmear_(-99999.),
      ecalRegressionScale_(-99999.),
      ecalRegressionSmear_(-99999.),
      ecalTrackRegressionScale_(-99999.),
      ecalTrackRegressionSmear_(-99999.),
      packedPFCandidates_(),
      associatedPackedFCandidateIndices_() {
  initImpactParameters();
}

Electron::Electron(const reco::GsfElectron& anElectron)
    : Lepton<reco::GsfElectron>(anElectron),
      embeddedGsfElectronCore_(false),
      embeddedGsfTrack_(false),
      embeddedSuperCluster_(false),
      embeddedPflowSuperCluster_(false),
      embeddedTrack_(false),
      embeddedSeedCluster_(false),
      embeddedRecHits_(false),
      embeddedPFCandidate_(false),
      ecalDrivenMomentum_(anElectron.p4()) {
  initImpactParameters();
}

Electron::Electron(const edm::RefToBase<reco::GsfElectron>& anElectronRef)
    : Lepton<reco::GsfElectron>(anElectronRef),
      embeddedGsfElectronCore_(false),
      embeddedGsfTrack_(false),
      embeddedSuperCluster_(false),
      embeddedPflowSuperCluster_(false),
      embeddedTrack_(false),
      embeddedSeedCluster_(false),
      embeddedRecHits_(false),
      embeddedPFCandidate_(false),
      ecalDrivenMomentum_(anElectronRef->p4()) {
  initImpactParameters();
}

Electron::Electron(const edm::Ptr<reco::GsfElectron>& anElectronRef)
    : Lepton<reco::GsfElectron>(anElectronRef),
      embeddedGsfElectronCore_(false),
      embeddedGsfTrack_(false),
      embeddedSuperCluster_(false),
      embeddedPflowSuperCluster_(false),
      embeddedTrack_(false),
      embeddedSeedCluster_(false),
      embeddedRecHits_(false),
      embeddedPFCandidate_(false),
      ecalDrivenMomentum_(anElectronRef->p4()) {
  initImpactParameters();
}

Electron::~Electron() {}

std::ostream& reco::operator<<(std::ostream& out, const pat::Electron& obj) {
  if (!out)
    return out;

  out << "\tpat::Electron: ";
  out << std::setiosflags(std::ios::right);
  out << std::setiosflags(std::ios::fixed);
  out << std::setprecision(3);
  out << " E/pT/eta/phi " << obj.energy() << "/" << obj.pt() << "/" << obj.eta() << "/" << obj.phi();
  return out;
}

void Electron::initImpactParameters() {
  std::fill(ip_, ip_ + IpTypeSize, 0.0f);
  std::fill(eip_, eip_ + IpTypeSize, 0.0f);
  cachedIP_ = 0;
}

reco::GsfTrackRef Electron::gsfTrack() const {
  if (embeddedGsfTrack_) {
    return reco::GsfTrackRef(&gsfTrack_, 0);
  } else {
    return reco::GsfElectron::gsfTrack();
  }
}

reco::GsfElectronCoreRef Electron::core() const {
  if (embeddedGsfElectronCore_) {
    return reco::GsfElectronCoreRef(&gsfElectronCore_, 0);
  } else {
    return reco::GsfElectron::core();
  }
}

reco::SuperClusterRef Electron::superCluster() const {
  if (embeddedSuperCluster_) {
    if (embeddedSeedCluster_ || !basicClusters_.empty() || !preshowerClusters_.empty()) {
      if (!superClusterRelinked_.isSet()) {
        std::unique_ptr<std::vector<reco::SuperCluster> > sc(new std::vector<reco::SuperCluster>(superCluster_));
        if (embeddedSeedCluster_ && !(*sc)[0].seed().isAvailable()) {
          (*sc)[0].setSeed(seed());
        }
        if (!basicClusters_.empty() && !(*sc)[0].clusters().isAvailable()) {
          reco::CaloClusterPtrVector clusters;
          for (unsigned int iclus = 0; iclus < basicClusters_.size(); ++iclus) {
            clusters.push_back(reco::CaloClusterPtr(&basicClusters_, iclus));
          }
          (*sc)[0].setClusters(clusters);
        }
        if (!preshowerClusters_.empty() && !(*sc)[0].preshowerClusters().isAvailable()) {
          reco::CaloClusterPtrVector clusters;
          for (unsigned int iclus = 0; iclus < preshowerClusters_.size(); ++iclus) {
            clusters.push_back(reco::CaloClusterPtr(&preshowerClusters_, iclus));
          }
          (*sc)[0].setPreshowerClusters(clusters);
        }
        superClusterRelinked_.set(std::move(sc));
      }
      return reco::SuperClusterRef(&*superClusterRelinked_, 0);
    } else {
      return reco::SuperClusterRef(&superCluster_, 0);
    }
    //relink caloclusters if needed
    return reco::SuperClusterRef(&superCluster_, 0);
  } else {
    return reco::GsfElectron::superCluster();
  }
}

reco::SuperClusterRef Electron::parentSuperCluster() const {
  if (embeddedPflowSuperCluster_) {
    return reco::SuperClusterRef(&pflowSuperCluster_, 0);
  } else {
    return reco::GsfElectron::parentSuperCluster();
  }
}

reco::CaloClusterPtr Electron::seed() const {
  if (embeddedSeedCluster_) {
    return reco::CaloClusterPtr(&seedCluster_, 0);
  } else {
    return reco::GsfElectron::superCluster()->seed();
  }
}

reco::TrackRef Electron::closestCtfTrackRef() const {
  if (embeddedTrack_) {
    return reco::TrackRef(&track_, 0);
  } else {
    return reco::GsfElectron::closestCtfTrackRef();
  }
}

// the name of the method is misleading, users should use gsfTrack of closestCtfTrack
reco::TrackRef Electron::track() const { return reco::TrackRef(); }

void Electron::embedGsfElectronCore() {
  gsfElectronCore_.clear();
  if (reco::GsfElectron::core().isNonnull()) {
    gsfElectronCore_.push_back(*reco::GsfElectron::core());
    embeddedGsfElectronCore_ = true;
  }
}

void Electron::embedGsfTrack() {
  gsfTrack_.clear();
  if (reco::GsfElectron::gsfTrack().isNonnull()) {
    gsfTrack_.push_back(*reco::GsfElectron::gsfTrack());
    embeddedGsfTrack_ = true;
  }
}

void Electron::embedSuperCluster() {
  superCluster_.clear();
  if (reco::GsfElectron::superCluster().isNonnull()) {
    superCluster_.push_back(*reco::GsfElectron::superCluster());
    embeddedSuperCluster_ = true;
  }
}

void Electron::embedPflowSuperCluster() {
  pflowSuperCluster_.clear();
  if (reco::GsfElectron::parentSuperCluster().isNonnull()) {
    pflowSuperCluster_.push_back(*reco::GsfElectron::parentSuperCluster());
    embeddedPflowSuperCluster_ = true;
  }
}

void Electron::embedSeedCluster() {
  seedCluster_.clear();
  if (reco::GsfElectron::superCluster().isNonnull() && reco::GsfElectron::superCluster()->seed().isNonnull()) {
    seedCluster_.push_back(*reco::GsfElectron::superCluster()->seed());
    embeddedSeedCluster_ = true;
  }
}

void Electron::embedBasicClusters() {
  basicClusters_.clear();
  if (reco::GsfElectron::superCluster().isNonnull()) {
    reco::CaloCluster_iterator itscl = reco::GsfElectron::superCluster()->clustersBegin();
    reco::CaloCluster_iterator itsclE = reco::GsfElectron::superCluster()->clustersEnd();
    for (; itscl != itsclE; ++itscl) {
      basicClusters_.push_back(**itscl);
    }
  }
}

void Electron::embedPreshowerClusters() {
  preshowerClusters_.clear();
  if (reco::GsfElectron::superCluster().isNonnull()) {
    reco::CaloCluster_iterator itscl = reco::GsfElectron::superCluster()->preshowerClustersBegin();
    reco::CaloCluster_iterator itsclE = reco::GsfElectron::superCluster()->preshowerClustersEnd();
    for (; itscl != itsclE; ++itscl) {
      preshowerClusters_.push_back(**itscl);
    }
  }
}

void Electron::embedPflowBasicClusters() {
  pflowBasicClusters_.clear();
  if (reco::GsfElectron::parentSuperCluster().isNonnull()) {
    reco::CaloCluster_iterator itscl = reco::GsfElectron::parentSuperCluster()->clustersBegin();
    reco::CaloCluster_iterator itsclE = reco::GsfElectron::parentSuperCluster()->clustersEnd();
    for (; itscl != itsclE; ++itscl) {
      pflowBasicClusters_.push_back(**itscl);
    }
  }
}

void Electron::embedPflowPreshowerClusters() {
  pflowPreshowerClusters_.clear();
  if (reco::GsfElectron::parentSuperCluster().isNonnull()) {
    reco::CaloCluster_iterator itscl = reco::GsfElectron::parentSuperCluster()->preshowerClustersBegin();
    reco::CaloCluster_iterator itsclE = reco::GsfElectron::parentSuperCluster()->preshowerClustersEnd();
    for (; itscl != itsclE; ++itscl) {
      pflowPreshowerClusters_.push_back(**itscl);
    }
  }
}

void Electron::embedTrack() {
  track_.clear();
  if (reco::GsfElectron::closestCtfTrackRef().isNonnull()) {
    track_.push_back(*reco::GsfElectron::closestCtfTrackRef());
    embeddedTrack_ = true;
  }
}

// method to store the RecHits internally
void Electron::embedRecHits(const EcalRecHitCollection* rechits) {
  if (rechits != nullptr) {
    recHits_ = *rechits;
    embeddedRecHits_ = true;
  }
}

float Electron::electronID(const std::string& name) const {
  for (std::vector<IdPair>::const_iterator it = electronIDs_.begin(), ed = electronIDs_.end(); it != ed; ++it) {
    if (it->first == name)
      return it->second;
  }
  cms::Exception ex("Key not found");
  ex << "pat::Electron: the ID " << name << " can't be found in this pat::Electron.\n";
  ex << "The available IDs are: ";
  for (std::vector<IdPair>::const_iterator it = electronIDs_.begin(), ed = electronIDs_.end(); it != ed; ++it) {
    ex << "'" << it->first << "' ";
  }
  ex << ".\n";
  throw ex;
}

bool Electron::isElectronIDAvailable(const std::string& name) const {
  for (std::vector<IdPair>::const_iterator it = electronIDs_.begin(), ed = electronIDs_.end(); it != ed; ++it) {
    if (it->first == name)
      return true;
  }
  return false;
}

reco::PFCandidateRef Electron::pfCandidateRef() const {
  if (embeddedPFCandidate_) {
    return reco::PFCandidateRef(&pfCandidate_, 0);
  } else {
    return pfCandidateRef_;
  }
}

void Electron::embedPFCandidate() {
  pfCandidate_.clear();
  if (pfCandidateRef_.isAvailable() && pfCandidateRef_.isNonnull()) {
    pfCandidate_.push_back(*pfCandidateRef_);
    embeddedPFCandidate_ = true;
  }
}

reco::CandidatePtr Electron::sourceCandidatePtr(size_type i) const {
  if (pfCandidateRef_.isNonnull()) {
    if (i == 0) {
      return reco::CandidatePtr(edm::refToPtr(pfCandidateRef_));
    } else {
      i--;
    }
  }
  if (i >= associatedPackedFCandidateIndices_.size()) {
    return reco::CandidatePtr();
  } else {
    return reco::CandidatePtr(edm::refToPtr(
        edm::Ref<pat::PackedCandidateCollection>(packedPFCandidates_, associatedPackedFCandidateIndices_[i])));
  }
}

double Electron::dB(IpType type_) const {
  // more IP types (new)
  if (cachedIP_ & (1 << int(type_))) {
    return ip_[type_];
  } else {
    return std::numeric_limits<double>::max();
  }
}

double Electron::edB(IpType type_) const {
  // more IP types (new)
  if (cachedIP_ & (1 << int(type_))) {
    return eip_[type_];
  } else {
    return std::numeric_limits<double>::max();
  }
}

void Electron::setDB(double dB, double edB, IpType type) {
  ip_[type] = dB;
  eip_[type] = edB;
  cachedIP_ |= (1 << int(type));
}

void Electron::setMvaVariables(double sigmaIetaIphi, double ip3d) {
  sigmaIetaIphi_ = sigmaIetaIphi;
  ip3d_ = ip3d;
}

edm::RefVector<pat::PackedCandidateCollection> Electron::associatedPackedPFCandidates() const {
  edm::RefVector<pat::PackedCandidateCollection> ret(packedPFCandidates_.id());
  for (uint16_t idx : associatedPackedFCandidateIndices_) {
    ret.push_back(edm::Ref<pat::PackedCandidateCollection>(packedPFCandidates_, idx));
  }
  return ret;
}