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.)),
    cachedDB_(false),
    dB_(0.0),
    edB_(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()),
    cachedDB_(false),
    dB_(0.0),
    edB_(0.0)
{
  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()),
    cachedDB_(false),
    dB_(0.0),
    edB_(0.0)
{
  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()),
    cachedDB_(false),
    dB_(0.0),
    edB_(0.0)
{
  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() {
  for (int i_ = 0; i_<5; ++i_){
    ip_.push_back(0.0);
    eip_.push_back(0.0);
    cachedIP_.push_back(false);
  }
}


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_.size() && !(*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_.size() && !(*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!=0) {
    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 {
  // preserve old functionality exactly
  if (type_ == None){
    if ( cachedDB_ ) {
      return dB_;
    } else {
      return std::numeric_limits<double>::max();
    }
  }
  // more IP types (new)
  else if ( cachedIP_[type_] ) {
    return ip_[type_];
  } else {
    return std::numeric_limits<double>::max();
  }
}

double Electron::edB(IpType type_) const {
  // preserve old functionality exactly
  if (type_ == None) {
    if ( cachedDB_ ) {
      return edB_;
    } else {
      return std::numeric_limits<double>::max();
    }
  }
  // more IP types (new)
  else if ( cachedIP_[type_] ) {
    return eip_[type_];
  } else {
    return std::numeric_limits<double>::max();
  }

}

void Electron::setDB(double dB, double edB, IpType type){
  if (type == None) { // Preserve  old functionality exactly
    dB_ = dB; edB_ = edB;
    cachedDB_ = true;
  } else {
    ip_[type] = dB; 
    eip_[type] = edB; 
    cachedIP_[type] = true;
  }
}

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

void Electron::setPackedPFCandidateCollection(const edm::RefProd<pat::PackedCandidateCollection> & refprod) {
    if (!associatedPackedFCandidateIndices_.empty()) throw cms::Exception("Unsupported", "You can't call setPackedPFCandidateCollection _after_ having called setAssociatedPackedPFCandidates");
    packedPFCandidates_ = refprod;
}

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;
}

void Electron::setAssociatedPackedPFCandidates(const edm::RefVector<pat::PackedCandidateCollection> &refvector) {
    if (packedPFCandidates_.isNonnull()) {
        if (refvector.id().isValid() && refvector.id() != packedPFCandidates_.id()) {
            throw cms::Exception("Unsupported", "setAssociatedPackedPFCandidates pointing to a collection other than the one from setPackedPFCandidateCollection");
        }
    } else {
        packedPFCandidates_ = edm::RefProd<pat::PackedCandidateCollection>(refvector);
    }
    associatedPackedFCandidateIndices_.clear();
    for (const edm::Ref<pat::PackedCandidateCollection> & ref : refvector) {
        associatedPackedFCandidateIndices_.push_back(ref.key());
    }
}