ConversionTools Class Reference

#include <ConversionTools.h>

Public Member Functions
	ConversionTools ()

Static Public Member Functions
static float	getVtxFitProb (const reco::Conversion *conv)
static bool	hasMatchedConversion (const reco::GsfElectron &ele, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, bool allowCkfMatch=true, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=0)
static bool	hasMatchedConversion (const reco::TrackRef &trk, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=1)
static bool	hasMatchedConversion (const reco::SuperCluster &sc, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, float dRMax=0.1, float dEtaMax=999., float dPhiMax=999., float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=1)
static bool	hasMatchedPromptElectron (const reco::SuperClusterRef &sc, const reco::GsfElectronCollection &eleCol, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, bool allowCkfMatch=true, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=0)
static bool	isGoodConversion (const reco::Conversion &conv, const math::XYZPoint &beamspot, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=1)
static reco::Conversion const *	matchedConversion (const reco::GsfElectron &ele, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, bool allowCkfMatch=true, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=0)
static reco::Conversion const *	matchedConversion (const reco::GsfElectronCore &eleCore, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, bool allowCkfMatch=true, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=0)
static reco::Conversion const *	matchedConversion (const reco::TrackRef &trk, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=1)
static reco::Conversion const *	matchedConversion (const reco::SuperCluster &sc, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, float dRMax=0.1, float dEtaMax=999., float dPhiMax=999., float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=1)
static reco::GsfElectron const *	matchedPromptElectron (const reco::SuperClusterRef &sc, const reco::GsfElectronCollection &eleCol, const reco::ConversionCollection &convCol, const math::XYZPoint &beamspot, bool allowCkfMatch=true, float lxyMin=2.0, float probMin=1e-6, unsigned int nHitsBeforeVtxMax=0)
static bool	matchesConversion (const reco::GsfElectron &ele, const reco::Conversion &conv, bool allowCkfMatch=true, bool allowAmbiguousGsfMatch=false)
static bool	matchesConversion (const reco::GsfElectronCore &eleCore, const reco::Conversion &conv, bool allowCkfMatch=true)
static bool	matchesConversion (const reco::SuperCluster &sc, const reco::Conversion &conv, float dRMax=0.1, float dEtaMax=999., float dPhiMax=999.)
static bool	matchesConversion (const edm::RefToBase< reco::Track > &trk, const reco::Conversion &conv)
static bool	matchesConversion (const reco::TrackRef &trk, const reco::Conversion &conv)
static bool	matchesConversion (const reco::GsfTrackRef &trk, const reco::Conversion &conv)

Detailed Description

Definition at line 35 of file ConversionTools.h.

Constructor & Destructor Documentation

ConversionTools::ConversionTools ( )

inline

Definition at line 37 of file ConversionTools.h.

References conv, photonValidator_cfi::dEtaMax, CSCSegmentAlgorithmRU_cfi::dPhiMax, metBenchmark_cfi::dRMax, MillePedeFileConverter_cfg::e, getVtxFitProb(), hasMatchedConversion(), hasMatchedPromptElectron(), isGoodConversion(), matchedConversion(), matchedPromptElectron(), matchesConversion(), recoSelectForWrite_cfi::probMin, and SimDataFormats::CaloAnalysis::sc.

{}

Member Function Documentation

float ConversionTools::getVtxFitProb ( const reco::Conversion *  conv )

static

Definition at line 441 of file ConversionTools.cc.

References reco::Vertex::chi2(), reco::Conversion::conversionVertex(), reco::Vertex::isValid(), reco::Vertex::ndof(), and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by ConversionTools(), GsfElectronAlgo::createElectron(), and EG9X105XObjectUpdateModifier::modifyObject().

                                                               {
  if (conv != nullptr) {
    const reco::Vertex &vtx = conv->conversionVertex();
    if (vtx.isValid()) {
      return TMath::Prob(vtx.chi2(), vtx.ndof());
    }
  }
  return -1;
}

bool ConversionTools::hasMatchedConversion ( const reco::GsfElectron &  ele, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, bool  allowCkfMatch = true, float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 0  )

static

Definition at line 184 of file ConversionTools.cc.

Referenced by ConversionTools(), LeptonSkimming::filter(), DQMExample_Step1::MediumEle(), GsfEleConversionVetoCut::operator()(), ElectronIdentifier::passID(), SoftPFElectronTagInfoProducer::produce(), pat::PATElectronProducer::produce(), EgammaCutBasedEleId::TestWP(), and GsfEleConversionVetoCut::value().

                                                                           {
  //check if a given electron candidate matches to at least one conversion candidate in the
  //collection which also passes the selection cuts, optionally match with the closestckf track in
  //in addition to just the gsf track (enabled in default arguments)

  for (auto const &it : convCol) {
    if (!matchesConversion(ele, it, allowCkfMatch))
      continue;
    if (!isGoodConversion(it, beamspot, lxyMin, probMin, nHitsBeforeVtxMax))
      continue;

    return true;
  }

  return false;
}

bool ConversionTools::hasMatchedConversion ( const reco::TrackRef &  trk, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 1  )

static

Definition at line 208 of file ConversionTools.cc.

References edm::Ref< C, T, F >::isNull().

                                                                           {
  //check if a given track matches to at least one conversion candidate in the
  //collection which also passes the selection cuts

  if (trk.isNull())
    return false;

  for (auto const &it : convCol) {
    if (!matchesConversion(trk, it))
      continue;
    if (!isGoodConversion(it, beamspot, lxyMin, probMin, nHitsBeforeVtxMax))
      continue;

    return true;
  }

  return false;
}

bool ConversionTools::hasMatchedConversion ( const reco::SuperCluster &  sc, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, float  dRMax = 0.1, float  dEtaMax = 999., float  dPhiMax = 999., float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 1  )

static

Definition at line 233 of file ConversionTools.cc.

                                                                           {
  //check if a given SuperCluster matches to at least one conversion candidate in the
  //collection which also passes the selection cuts

  for (auto const &it : convCol) {
    if (!matchesConversion(sc, it))
      continue;
    if (!isGoodConversion(it, beamspot, lxyMin, probMin, nHitsBeforeVtxMax))
      continue;

    return true;
  }

  return false;
}

bool ConversionTools::hasMatchedPromptElectron ( const reco::SuperClusterRef &  sc, const reco::GsfElectronCollection &  eleCol, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, bool  allowCkfMatch = true, float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 0  )

static

Definition at line 392 of file ConversionTools.cc.

Referenced by ConversionTools(), and pat::PATPhotonProducer::produce().

                                                                               {
  return !(matchedPromptElectron(sc, eleCol, convCol, beamspot, allowCkfMatch, lxyMin, probMin, nHitsBeforeVtxMax) ==
           nullptr);
}

bool ConversionTools::isGoodConversion ( const reco::Conversion &  conv, const math::XYZPoint &  beamspot, float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 1  )

static

Definition at line 16 of file ConversionTools.cc.

References reco::Vertex::chi2(), reco::Conversion::conversionVertex(), reco::Vertex::isValid(), reco::Vertex::ndof(), reco::Conversion::nHitsBeforeVtx(), reco::Conversion::refittedPairMomentum(), badGlobalMuonTaggersAOD_cff::vtx, reco::Vertex::x(), and reco::Vertex::y().

Referenced by ConversionTools().

                                                                       {
  //Check if a given conversion candidate passes the conversion selection cuts

  const reco::Vertex &vtx = conv.conversionVertex();

  //vertex validity
  if (!vtx.isValid())
    return false;

  //fit probability
  if (TMath::Prob(vtx.chi2(), vtx.ndof()) < probMin)
    return false;

  //compute transverse decay length
  math::XYZVector mom(conv.refittedPairMomentum());
  double dbsx = vtx.x() - beamspot.x();
  double dbsy = vtx.y() - beamspot.y();
  double lxy = (mom.x() * dbsx + mom.y() * dbsy) / mom.rho();

  //transverse decay length
  if (lxy < lxyMin)
    return false;

  //loop through daughters to check nhitsbeforevtx
  for (std::vector<uint8_t>::const_iterator it = conv.nHitsBeforeVtx().begin(); it != conv.nHitsBeforeVtx().end();
       ++it) {
    if ((*it) > nHitsBeforeVtxMax)
      return false;
  }

  return true;
}

reco::Conversion const * ConversionTools::matchedConversion ( const reco::GsfElectron &  ele, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, bool  allowCkfMatch = true, float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 0  )

static

Definition at line 258 of file ConversionTools.cc.

References edm::match().

Referenced by ElectronConversionRejectionValidator::analyze(), ConversionTools(), GsfElectronAlgo::createElectron(), and EG9X105XObjectUpdateModifier::modifyObject().

                                                                                           {
  //check if a given electron candidate matches to at least one conversion candidate in the
  //collection which also passes the selection cuts, optionally match with the closestckf track in
  //in addition to just the gsf track (enabled in default arguments)
  //If multiple conversions are found, returned reference corresponds to minimum
  //conversion radius

  reco::Conversion const *match = nullptr;

  double minRho = 999.;
  for (auto const &it : convCol) {
    float rho = it.conversionVertex().position().rho();
    if (rho > minRho)
      continue;
    if (!matchesConversion(ele, it, allowCkfMatch))
      continue;
    if (!isGoodConversion(it, beamspot, lxyMin, probMin, nHitsBeforeVtxMax))
      continue;

    minRho = rho;
    match = ⁢
  }

  return match;
}

reco::Conversion const * ConversionTools::matchedConversion ( const reco::GsfElectronCore &  eleCore, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, bool  allowCkfMatch = true, float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 0  )

static

Definition at line 291 of file ConversionTools.cc.

References edm::match().

                                                                                           {
  //check if a given electron candidate matches to at least one conversion candidate in the
  //collection which also passes the selection cuts, optionally match with the closestckf track in
  //in addition to just the gsf track (enabled in default arguments)
  //If multiple conversions are found, returned reference corresponds to minimum
  //conversion radius

  reco::Conversion const *match = nullptr;

  double minRho = 999.;
  for (auto const &it : convCol) {
    float rho = it.conversionVertex().position().rho();
    if (rho > minRho)
      continue;
    if (!matchesConversion(eleCore, it, allowCkfMatch))
      continue;
    if (!isGoodConversion(it, beamspot, lxyMin, probMin, nHitsBeforeVtxMax))
      continue;

    minRho = rho;
    match = ⁢
  }

  return match;
}

reco::Conversion const * ConversionTools::matchedConversion ( const reco::TrackRef &  trk, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 1  )

static

Definition at line 324 of file ConversionTools.cc.

References edm::Ref< C, T, F >::isNull(), and edm::match().

                                                                                           {
  //check if a given track matches to at least one conversion candidate in the
  //collection which also passes the selection cuts
  //If multiple conversions are found, returned reference corresponds to minimum
  //conversion radius

  reco::Conversion const *match = nullptr;

  if (trk.isNull())
    return match;

  double minRho = 999.;
  for (auto const &it : convCol) {
    float rho = it.conversionVertex().position().rho();
    if (rho > minRho)
      continue;
    if (!matchesConversion(trk, it))
      continue;
    if (!isGoodConversion(it, beamspot, lxyMin, probMin, nHitsBeforeVtxMax))
      continue;

    minRho = rho;
    match = ⁢
  }

  return match;
}

reco::Conversion const * ConversionTools::matchedConversion ( const reco::SuperCluster &  sc, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, float  dRMax = 0.1, float  dEtaMax = 999., float  dPhiMax = 999., float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 1  )

static

Definition at line 358 of file ConversionTools.cc.

References edm::match().

                                                                                           {
  //check if a given SuperCluster matches to at least one conversion candidate in the
  //collection which also passes the selection cuts
  //If multiple conversions are found, returned reference corresponds to minimum
  //conversion radius

  reco::Conversion const *match = nullptr;

  double minRho = 999.;
  for (auto const &it : convCol) {
    float rho = it.conversionVertex().position().rho();
    if (rho > minRho)
      continue;
    if (!matchesConversion(sc, it, dRMax, dEtaMax, dPhiMax))
      continue;
    if (!isGoodConversion(it, beamspot, lxyMin, probMin, nHitsBeforeVtxMax))
      continue;

    minRho = rho;
    match = ⁢
  }

  return match;
}

reco::GsfElectron const * ConversionTools::matchedPromptElectron ( const reco::SuperClusterRef &  sc, const reco::GsfElectronCollection &  eleCol, const reco::ConversionCollection &  convCol, const math::XYZPoint &  beamspot, bool  allowCkfMatch = true, float  lxyMin = 2.0, float  probMin = 1e-6, unsigned int  nHitsBeforeVtxMax = 0  )

static

Definition at line 405 of file ConversionTools.cc.

References edm::Ref< C, T, F >::isNull(), edm::match(), reco::HitPattern::MISSING_INNER_HITS, and SimDataFormats::CaloAnalysis::sc.

Referenced by ConversionTools().

                                                                                                {
  //check if a given SuperCluster matches to at least one GsfElectron having zero expected inner hits
  //and not matching any conversion in the collection passing the quality cuts

  reco::GsfElectron const *match = nullptr;

  if (sc.isNull())
    return match;

  for (auto const &it : eleCol) {
    //match electron to supercluster
    if (it.superCluster() != sc)
      continue;

    //check expected inner hits
    if (it.gsfTrack()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) > 0)
      continue;

    //check if electron is matching to a conversion
    if (hasMatchedConversion(it, convCol, beamspot, allowCkfMatch, lxyMin, probMin, nHitsBeforeVtxMax))
      continue;

    match = ⁢
  }

  return match;
}

bool ConversionTools::matchesConversion ( const reco::GsfElectron &  ele, const reco::Conversion &  conv, bool  allowCkfMatch = true, bool  allowAmbiguousGsfMatch = false  )

static

Definition at line 54 of file ConversionTools.cc.

References reco::GsfElectron::ambiguousGsfTracksBegin(), reco::GsfElectron::ambiguousGsfTracksEnd(), and reco::Conversion::tracks().

Referenced by PF_PU_AssoMapAlgos::ComesFromConversion(), ConversionTools(), ReducedEGProducer::linkConversionsByTrackRef(), and pat::PATConversionProducer::produce().

                                                                     {
  //check if a given GsfElectron matches a given conversion (no quality cuts applied)
  //matching is always attempted through the gsf track ref, and optionally attempted through the
  //closest ctf track ref

  const std::vector<edm::RefToBase<reco::Track> > &convTracks = conv.tracks();
  for (std::vector<edm::RefToBase<reco::Track> >::const_iterator it = convTracks.begin(); it != convTracks.end();
       ++it) {
    if (ele.reco::GsfElectron::gsfTrack().isNonnull() && ele.reco::GsfElectron::gsfTrack().id() == it->id() &&
        ele.reco::GsfElectron::gsfTrack().key() == it->key())
      return true;
    else if (allowCkfMatch && ele.reco::GsfElectron::closestCtfTrackRef().isNonnull() &&
             ele.reco::GsfElectron::closestCtfTrackRef().id() == it->id() &&
             ele.reco::GsfElectron::closestCtfTrackRef().key() == it->key())
      return true;
    if (allowAmbiguousGsfMatch) {
      for (reco::GsfTrackRefVector::const_iterator tk = ele.ambiguousGsfTracksBegin();
           tk != ele.ambiguousGsfTracksEnd();
           ++tk) {
        if (tk->isNonnull() && tk->id() == it->id() && tk->key() == it->key())
          return true;
      }
    }
  }

  return false;
}

bool ConversionTools::matchesConversion ( const reco::GsfElectronCore &  eleCore, const reco::Conversion &  conv, bool  allowCkfMatch = true  )

static

Definition at line 86 of file ConversionTools.cc.

References reco::GsfElectronCore::ctfTrack(), reco::GsfElectronCore::gsfTrack(), edm::ProductID::id(), edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), and reco::Conversion::tracks().

                                                            {
  //check if a given GsfElectronCore matches a given conversion (no quality cuts applied)
  //matching is always attempted through the gsf track ref, and optionally attempted through the
  //closest ctf track ref

  for (const auto &trkRef : conv.tracks()) {
    if (eleCore.gsfTrack().isNonnull() && eleCore.gsfTrack().id() == trkRef.id() &&
        eleCore.gsfTrack().key() == trkRef.key())
      return true;
    else if (allowCkfMatch && eleCore.ctfTrack().isNonnull() && eleCore.ctfTrack().id() == trkRef.id() &&
             eleCore.ctfTrack().key() == trkRef.key())
      return true;
  }

  return false;
}

bool ConversionTools::matchesConversion ( const reco::SuperCluster &  sc, const reco::Conversion &  conv, float  dRMax = 0.1, float  dEtaMax = 999., float  dPhiMax = 999.  )

static

Definition at line 106 of file ConversionTools.cc.

References reco::Conversion::conversionVertex(), reco::deltaPhi(), reco::deltaR(), HLT_2018_cff::dEta, HLT_2018_cff::dPhi, HGC3DClusterGenMatchSelector_cfi::dR, reco::Vertex::position(), reco::CaloCluster::position(), and reco::Conversion::refittedPairMomentum().

                                                                                                       {
  //check if a given SuperCluster matches a given conversion (no quality cuts applied)
  //matching is geometric between conversion momentum and vector joining conversion vertex
  //to supercluster position

  math::XYZVector mom(conv.refittedPairMomentum());

  const math::XYZPoint &scpos(sc.position());
  math::XYZPoint cvtx(conv.conversionVertex().position());

  math::XYZVector cscvector = scpos - cvtx;
  float dR = reco::deltaR(mom, cscvector);
  float dEta = mom.eta() - cscvector.eta();
  float dPhi = reco::deltaPhi(mom.phi(), cscvector.phi());

  if (dR > dRMax)
    return false;
  if (dEta > dEtaMax)
    return false;
  if (dPhi > dPhiMax)
    return false;

  return true;
}

bool ConversionTools::matchesConversion ( const edm::RefToBase< reco::Track > &  trk, const reco::Conversion &  conv  )

static

Definition at line 133 of file ConversionTools.cc.

References edm::ProductID::id(), edm::RefToBase< T >::id(), edm::RefToBase< T >::isNull(), edm::RefToBase< T >::key(), and reco::Conversion::tracks().

                                                                                                      {
  //check if given track matches given conversion (matching by ref)

  if (trk.isNull())
    return false;

  const std::vector<edm::RefToBase<reco::Track> > &convTracks = conv.tracks();
  for (std::vector<edm::RefToBase<reco::Track> >::const_iterator it = convTracks.begin(); it != convTracks.end();
       ++it) {
    if (trk.id() == it->id() && trk.key() == it->key())
      return true;
  }

  return false;
}

bool ConversionTools::matchesConversion ( const reco::TrackRef &  trk, const reco::Conversion &  conv  )

static

Definition at line 150 of file ConversionTools.cc.

References edm::ProductID::id(), edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::isNull(), edm::Ref< C, T, F >::key(), and reco::Conversion::tracks().

                                                                                           {
  //check if given track matches given conversion (matching by ref)

  if (trk.isNull())
    return false;

  const std::vector<edm::RefToBase<reco::Track> > &convTracks = conv.tracks();
  for (std::vector<edm::RefToBase<reco::Track> >::const_iterator it = convTracks.begin(); it != convTracks.end();
       ++it) {
    if (trk.id() == it->id() && trk.key() == it->key())
      return true;
  }

  return false;
}

bool ConversionTools::matchesConversion ( const reco::GsfTrackRef &  trk, const reco::Conversion &  conv  )

static

Definition at line 167 of file ConversionTools.cc.

References edm::ProductID::id(), edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::isNull(), edm::Ref< C, T, F >::key(), and reco::Conversion::tracks().

                                                                                              {
  //check if given track matches given conversion (matching by ref)

  if (trk.isNull())
    return false;

  const std::vector<edm::RefToBase<reco::Track> > &convTracks = conv.tracks();
  for (std::vector<edm::RefToBase<reco::Track> >::const_iterator it = convTracks.begin(); it != convTracks.end();
       ++it) {
    if (trk.id() == it->id() && trk.key() == it->key())
      return true;
  }

  return false;
}