DerivationFramework::EGElectronAmbiguityTool Class Reference

#include <EGElectronAmbiguityTool.h>

Inheritance diagram for DerivationFramework::EGElectronAmbiguityTool:

Collaboration diagram for DerivationFramework::EGElectronAmbiguityTool:

Classes
struct	DecorHandles

Public Member Functions
virtual StatusCode	initialize () override final
virtual StatusCode	addBranches (const EventContext &ctx) const override final

Private Member Functions
StatusCode	decorateSimple (DecorHandles &dh, std::unique_ptr< ConstDataVector< xAOD::TrackParticleContainer > > &tpC, const xAOD::Electron *ele, const xAOD::Vertex *pvtx) const

Private Attributes
SG::ReadHandleKey< xAOD::ElectronContainer >	m_containerName
SG::ReadHandleKey< xAOD::VertexContainer >	m_VtxContainerName
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_tpContainerName
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_tpCName
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_drv { this, "DFCommonSimpleConvRadius", m_containerName, "DFCommonSimpleConvRadius", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dphiv { this, "DFCommonSimpleConvPhi", m_containerName, "DFCommonSimpleConvPhi", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dmee { this, "DFCommonSimpleMee", m_containerName, "DFCommonSimpleMee", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dmeeVtx { this, "DFCommonSimpleMeeAtVtx", m_containerName, "DFCommonSimpleMeeAtVtx", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dsep { this, "DFCommonSimpleSeparation", m_containerName, "DFCommonSimpleSeparation", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dambi { this, "DFCommonAddAmbiguity", m_containerName, "DFCommonAddAmbiguity", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dtrv { this, "DFCommonProdTrueRadius", m_containerName, "DFCommonProdTrueRadius", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dtpv { this, "DFCommonProdTruePhi", m_containerName, "DFCommonProdTruePhi", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dtzv { this, "DFCommonProdTrueZ", m_containerName, "DFCommonProdTrueZ", "" }
Gaudi::Property< bool >	m_isMC {this, "isMC", false}
Gaudi::Property< double >	m_elepTCut
Gaudi::Property< std::string >	m_idCut
Gaudi::Property< unsigned int >	m_nSiCut
Gaudi::Property< double >	m_dctCut
Gaudi::Property< double >	m_sepCut
Gaudi::Property< double >	m_dzCut
Gaudi::Property< double >	m_rvECCut
Gaudi::Property< double >	m_meeAtVtxECCut
Gaudi::Property< double >	m_meeICCut

Friends
struct	DecorHandles

Detailed Description

Definition at line 29 of file EGElectronAmbiguityTool.h.

Member Function Documentation

addBranches()

StatusCode DerivationFramework::EGElectronAmbiguityTool::addBranches ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 88 of file EGElectronAmbiguityTool.cxx.

{
 
  DecorHandles dh (*this, ctx);
 
  static const SG::ConstAccessor<char> aidCut(m_idCut);
 
  // retrieve primary vertex
  const xAOD::Vertex* pvtx(nullptr);
  SG::ReadHandle<xAOD::VertexContainer> inputVtx{ m_VtxContainerName, ctx };
  if (inputVtx.ptr()){
    const xAOD::VertexContainer* vtxC = inputVtx.ptr();
    for (const auto* vertex : *vtxC) {
      if (vertex->vertexType() == xAOD::VxType::VertexType::PriVtx) {
        pvtx = vertex;
        break;
      }
    }
  }
 
  // retrieve electron container
  SG::ReadHandle<xAOD::ElectronContainer> inputElectrons{ m_containerName,
                                                          ctx };
  const xAOD::ElectronContainer* eleC = inputElectrons.ptr();
 
  if (!eleC) {
    ATH_MSG_ERROR(
      "Couldn't retrieve Electron container with key: " << m_containerName);
    return StatusCode::FAILURE;
  }
  if (!pvtx) {
    ATH_MSG_DEBUG("No primary vertex found. Setting default values.");
    for (const xAOD::Electron* iele : *eleC) {
      dh.drv(*iele) = -1;
      dh.dphiv(*iele) = -1;
      dh.dmee(*iele) = -1;
      dh.dmeeVtx(*iele) = -1;
      dh.dsep(*iele) = -1;
      dh.dambi(*iele) = -1;
      dh.dtrv(*iele) = -1;
      dh.dtpv(*iele) = -1;
      dh.dtzv(*iele) = -1;
    }
    return StatusCode::SUCCESS;
  }
  ATH_MSG_DEBUG("Pvx z = " << pvtx->z() << ", number of electrons "
                           << eleC->size());
 
  // Make a container of selected tracks : with Si hits, close to electron track
  SG::ReadHandle<xAOD::TrackParticleContainer> inputTrackParticles{
    m_tpContainerName, ctx
  };
  const xAOD::TrackParticleContainer* idtpC = inputTrackParticles.ptr();
 
  std::set<const xAOD::TrackParticle*> alreadyStored;
  std::set<const xAOD::TrackParticle*> eleIDtpStored, eleGSFtpStored;
  auto closeByTracks =
    std::make_unique<ConstDataVector<xAOD::TrackParticleContainer>>(
      SG::VIEW_ELEMENTS);
 
  for (const auto* ele : *eleC) {
 
    dh.dambi(*ele) = -1;
 
    // Electron preselection
    if (ele->pt() < m_elepTCut ||
        m_idCut.empty() || !aidCut.isAvailable(*ele) || !aidCut(*ele))
      continue;
 
    // Just for debug
    const xAOD::TrackParticle* eleGSFtp = ele->trackParticle();
    eleGSFtpStored.insert(eleGSFtp);
 
    const xAOD::TrackParticle* eleIDtp =
      xAOD::EgammaHelpers::getOriginalTrackParticle(ele);
    eleIDtpStored.insert(eleIDtp);
 
    // The loop on track
    for (const auto* tp : *idtpC) {
 
      // Keep the electron track (I build a container to run vertexing on it...)
      if (tp == eleIDtp) {
        closeByTracks->push_back(tp);
        alreadyStored.insert(tp);
        continue;
      }
 
      // potential candidate to store if not already there
      if (alreadyStored.find(tp) != alreadyStored.end())
        continue;

      // if (tp->charge() * ele->charge() > 0)
      //  continue;
 
      // Close-by
      double dR = eleIDtp->p4().DeltaR(tp->p4());
      double dz = std::abs(eleIDtp->z0() - tp->z0()) * std::sin(eleIDtp->theta());
      if (dR >= 0.3 || dz >= m_dzCut)
        continue;
 
      // With minimum number of Si hits
      if (xAOD::EgammaHelpers::numberOfSiHits(tp) < m_nSiCut)
        continue;
 
      alreadyStored.insert(tp);
 
      closeByTracks->push_back(tp);
    }
  }
 
  if (closeByTracks->empty())
    return StatusCode::SUCCESS;
 
  if (msgLvl(MSG::DEBUG)) {
    SG::ReadHandle<xAOD::TrackParticleContainer> tpCReadHandle{ m_tpCName,
                                                                ctx };
    const xAOD::TrackParticleContainer* tpC = tpCReadHandle.ptr();
 
    ATH_MSG_DEBUG("Number of input tracks "
                  << idtpC->size() << " , number of selected close-by tracks "
                  << closeByTracks->size() << " , number of GSF tracks "
                  << tpC->size());
    for (const auto* trk : eleIDtpStored)
      ATH_MSG_DEBUG("ele  ID trk "
                    << trk << " pt = " << trk->pt() * 1e-3
                    << " eta = " << trk->eta() << " phi = " << trk->phi()
                    << " nSi = " << xAOD::EgammaHelpers::numberOfSiHits(trk));
    for (const auto* trk : eleGSFtpStored)
      ATH_MSG_DEBUG("ele GSF trk "
                    << trk << " pt = " << trk->pt() * 1e-3
                    << " eta = " << trk->eta() << " phi = " << trk->phi()
                    << " nSi = " << xAOD::EgammaHelpers::numberOfSiHits(trk));
    for (const xAOD::TrackParticle* trk : *closeByTracks)
      ATH_MSG_DEBUG("closeby trk "
                    << trk << " pt = " << trk->pt() * 1e-3
                    << " eta = " << trk->eta() << " phi = " << trk->phi()
                    << " nSi = " << xAOD::EgammaHelpers::numberOfSiHits(trk));
  }
 
  for (const auto* ele : *eleC) {
 
    // Electron preselection
    if (ele->pt() < m_elepTCut ||
        m_idCut.empty() || !aidCut.isAvailable(*ele) || !aidCut(*ele))
      continue;
 
    // Henri's circles
    if (decorateSimple(dh, closeByTracks, ele, pvtx).isFailure()) {
      ATH_MSG_ERROR("Cannot decorate the electron with the simple info");
      return StatusCode::FAILURE;
    }
 
  } // loop on electrons to decorate
 
  return StatusCode::SUCCESS;
}

decorateSimple()

StatusCode DerivationFramework::EGElectronAmbiguityTool::decorateSimple ( DecorHandles & dh, std::unique_ptr< ConstDataVector< xAOD::TrackParticleContainer > > & tpC, const xAOD::Electron * ele, const xAOD::Vertex * pvtx ) const

private

HelixToCircle Main Track Electron

HelixToCircle Other Electron Conv Track

Definition at line 248 of file EGElectronAmbiguityTool.cxx.

{
  // This is the GSF electron track
  const xAOD::TrackParticle* eleGSFtrkP = ele->trackParticle();
 
  // And the ID one
  const xAOD::TrackParticle* eleIDtrkP =
    xAOD::EgammaHelpers::getOriginalTrackParticle(ele);
 
  // For the time being, use the ID one, to be consistent when we only find a
  // good ID to make a conversion and no GSF
  bool useGSF = false; // hardcoded because it seems we will not use true. Kept
                       // for the time being, as not 100% sure
  const xAOD::TrackParticle* eletrkP = useGSF ? eleGSFtrkP : eleIDtrkP;
 
  ATH_MSG_DEBUG("Electron pt = " << ele->pt() * 1e-3 << " eta = " << ele->eta()
                                 << " phi = " << ele->phi() << " GSF trk ptr = "
                                 << eleGSFtrkP << " ID trk ptr " << eleIDtrkP);
 
  if (m_isMC) {
    const xAOD::TruthParticle* truthEl =
      xAOD::TruthHelpers::getTruthParticle(*ele);
    double tpvr = -1, tpvp = 9e9, tpvz = 9e9;
    if (truthEl && MC::isElectron(truthEl) &&
        truthEl->prodVtx() != nullptr) {
      tpvr = truthEl->prodVtx()->perp();
      tpvp = truthEl->prodVtx()->phi();
      tpvz = truthEl->prodVtx()->z();
    }
    dh.dtrv(*ele) = tpvr;
    dh.dtpv(*ele) = tpvp;
    dh.dtzv(*ele) = tpvz;
  }
 
  // Find the closest track particle with opposite charge and a minimum nb of Si
  // hits
  const xAOD::TrackParticle* otrkP(nullptr);
  double detaMin = 9e9;
  for (const xAOD::TrackParticle* tp : *tpC) {
    // Keep only opposite charge
    if (tp->charge() * eletrkP->charge() > 0)
      continue;
 
    // Close-by
    double dR = eletrkP->p4().DeltaR(tp->p4());
    double dz = std::abs(eletrkP->z0() - tp->z0()) * std::sin(eletrkP->theta());
    if (dR >= 0.3 || dz >= m_dzCut)
      continue;
 
    double deta = std::abs(eletrkP->eta() - tp->eta());
    if (deta < detaMin) {
      otrkP = tp;
      detaMin = deta;
    }
  }
 
  double rv = -9e9;
  double pv = -9e9;
  double mee = -1.;
  double meeAtVtx = -1.;
  double sep = -9e9;
  bool goodConv = false;
 
  if (otrkP) {
 
    // To be consistent with the other, use the ID track.
    TLorentzVector ep4;
    ep4.SetPtEtaPhiM(eletrkP->pt(), eletrkP->eta(), eletrkP->phi(), ParticleConstants::electronMassInMeV);
 
    // Maybe could see if a GSF tp exists for this ID tp and use it if yes ?
    TLorentzVector op4;
    op4.SetPtEtaPhiM(otrkP->pt(), otrkP->eta(), otrkP->phi(), ParticleConstants::electronMassInMeV);
 
    // Simple masses
    mee = (ep4 + op4).M();
    op4.SetPhi(eletrkP->phi());
    meeAtVtx = (ep4 + op4).M();
 
    // And the conversion point
    std::vector<double> helix1, helix2;
    helix1.resize(5);
    helix2.resize(5);
    helix(eletrkP, pvtx, helix1);
    helix(otrkP, pvtx, helix2);
 
    double beta(0.);
    if (helix1[4] < helix2[4])
      beta = PiOver2 - helix1[4];
    else
      beta = PiOver2 - helix2[4];
 
    double phi1(helix1[4] + beta);
    if (phi1 > TwoPi)
      phi1 -= TwoPi;
    if (phi1 < 0.)
      phi1 += TwoPi;
 
    double phi2(helix2[4] + beta);
    if (phi2 > TwoPi)
      phi2 -= TwoPi;
    if (phi2 < 0.)
      phi2 += TwoPi;

    double r1 = 1 / (2. * std::abs(helix1[1]));
 
    double charge1(1.);
    if (helix1[1] < 0.)
      charge1 = -1.;
    double rcenter1(helix1[3] / charge1 + r1);
    double phicenter1(phi1 + PiOver2 * charge1);
 
    double x1 = rcenter1 * std::cos(phicenter1);
    double y1 = rcenter1 * std::sin(phicenter1);

    double r2 = 1 / (2. * std::abs(helix2[1]));
 
    double charge2(1.);
    if (helix2[1] < 0.)
      charge2 = -1.;
    double rcenter2(helix2[3] / charge2 + r2);
    double phicenter2(phi2 + PiOver2 * charge2);
 
    double x2 = rcenter2 * std::cos(phicenter2);
    double y2 = rcenter2 * std::sin(phicenter2);
 
    double dx = x1 - x2;
    if (std::abs(dx) < 1e-9) {
      dx = std::copysign(1e-9, dx);
    }
    double slope((y1 - y2) / dx);
    double b(y1 - slope * x1);
    double alpha(std::atan(slope));
    double d(std::sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
    // only keeping opposite sign option
    double separation = d - r1 - r2;
    double cpx1, cpx2;
    if (x1 > x2) {
      cpx1 = x1 - r1 * std::cos(alpha);
      cpx2 = x2 + r2 * std::cos(alpha);
    } else {
      cpx1 = x1 + r1 * std::cos(alpha);
      cpx2 = x2 - r2 * std::cos(alpha);
    }
 
    double temp1 = (cpx1 + cpx2) / 2;
    double temp2 = slope * temp1 + b;
    double convX = std::cos(beta) * temp1 + std::sin(beta) * temp2;
    double convY = -std::sin(beta) * temp1 + std::cos(beta) * temp2;
 
    double dct(helix1[0] - helix2[0]);

    if (std::abs(separation) < m_sepCut && std::abs(dct) < m_dctCut) {
      goodConv = true;
      sep = separation;
      pv = std::atan2(convY, convX);
      rv = std::sqrt(convX * convX + convY * convY);
      if (convX * std::cos(eletrkP->phi()) + convY * std::sin(eletrkP->phi()) < 0)
        rv *= -1.;
    }
  } else {
    dh.dambi(*ele) = -1;
  }
  dh.drv(*ele) = rv;
  dh.dphiv(*ele) = pv;
  dh.dmee(*ele) = mee;
  dh.dmeeVtx(*ele) = meeAtVtx;
  dh.dsep(*ele) = sep;
  if (goodConv && rv > m_rvECCut && meeAtVtx < m_meeAtVtxECCut)
    dh.dambi(*ele) = 2;
  else if (otrkP) {
    if (mee < m_meeICCut)
      dh.dambi(*ele) = 1;
    else
      dh.dambi(*ele) = 0;
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::EGElectronAmbiguityTool::initialize ( )

finaloverridevirtual

Definition at line 52 of file EGElectronAmbiguityTool.cxx.

{
 
  ATH_CHECK(m_containerName.initialize());
  ATH_CHECK(m_VtxContainerName.initialize());
  ATH_CHECK(m_tpContainerName.initialize());
  ATH_CHECK(m_tpCName.initialize());
 
  ATH_CHECK(m_drv.initialize());
  ATH_CHECK(m_dphiv.initialize());
  ATH_CHECK(m_dmee.initialize());
  ATH_CHECK(m_dmeeVtx.initialize());
  ATH_CHECK(m_dsep.initialize());
  ATH_CHECK(m_dambi.initialize());
  ATH_CHECK(m_dtrv.initialize());
  ATH_CHECK(m_dtpv.initialize());
  ATH_CHECK(m_dtzv.initialize());
 
  return StatusCode::SUCCESS;
}

Friends And Related Symbol Documentation

DecorHandles

friend struct DecorHandles

friend

Definition at line 106 of file EGElectronAmbiguityTool.h.

Member Data Documentation

m_containerName

SG::ReadHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_containerName

private

Initial value:

{
      this,
        "ContainerName",
        "Electrons",
        "SG key of electron container"
        }

Definition at line 40 of file EGElectronAmbiguityTool.h.

                                                          {
      this,
        "ContainerName",
        "Electrons",
        "SG key of electron container"
        };

m_dambi

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_dambi { this, "DFCommonAddAmbiguity", m_containerName, "DFCommonAddAmbiguity", "" }

private

Definition at line 83 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonAddAmbiguity", m_containerName, "DFCommonAddAmbiguity", "" };

m_dctCut

Gaudi::Property<double> DerivationFramework::EGElectronAmbiguityTool::m_dctCut

private

Initial value:

{
      this, "DCTCut", 0.02, "second separation cut"}

Definition at line 125 of file EGElectronAmbiguityTool.h.

                                  {
      this, "DCTCut", 0.02, "second separation cut"};

m_dmee

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_dmee { this, "DFCommonSimpleMee", m_containerName, "DFCommonSimpleMee", "" }

private

Definition at line 74 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonSimpleMee", m_containerName, "DFCommonSimpleMee", "" };

m_dmeeVtx

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_dmeeVtx { this, "DFCommonSimpleMeeAtVtx", m_containerName, "DFCommonSimpleMeeAtVtx", "" }

private

Definition at line 77 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonSimpleMeeAtVtx", m_containerName, "DFCommonSimpleMeeAtVtx", "" };

m_dphiv

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_dphiv { this, "DFCommonSimpleConvPhi", m_containerName, "DFCommonSimpleConvPhi", "" }

private

Definition at line 71 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonSimpleConvPhi", m_containerName, "DFCommonSimpleConvPhi", "" };

m_drv

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_drv { this, "DFCommonSimpleConvRadius", m_containerName, "DFCommonSimpleConvRadius", "" }

private

Definition at line 68 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonSimpleConvRadius", m_containerName, "DFCommonSimpleConvRadius", "" };

m_dsep

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_dsep { this, "DFCommonSimpleSeparation", m_containerName, "DFCommonSimpleSeparation", "" }

private

Definition at line 80 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonSimpleSeparation", m_containerName, "DFCommonSimpleSeparation", "" };

m_dtpv

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_dtpv { this, "DFCommonProdTruePhi", m_containerName, "DFCommonProdTruePhi", "" }

private

Definition at line 89 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonProdTruePhi", m_containerName, "DFCommonProdTruePhi", "" };

m_dtrv

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_dtrv { this, "DFCommonProdTrueRadius", m_containerName, "DFCommonProdTrueRadius", "" }

private

Definition at line 86 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonProdTrueRadius", m_containerName, "DFCommonProdTrueRadius", "" };

m_dtzv

SG::WriteDecorHandleKey<xAOD::ElectronContainer> DerivationFramework::EGElectronAmbiguityTool::m_dtzv { this, "DFCommonProdTrueZ", m_containerName, "DFCommonProdTrueZ", "" }

private

Definition at line 92 of file EGElectronAmbiguityTool.h.

{ this, "DFCommonProdTrueZ", m_containerName, "DFCommonProdTrueZ", "" };

m_dzCut

Gaudi::Property<double> DerivationFramework::EGElectronAmbiguityTool::m_dzCut

private

Initial value:

{
      this, "dzsinTCut", 0.5, "max dz sinTheta between ele and other tracks"}

Definition at line 129 of file EGElectronAmbiguityTool.h.

                                 {
      this, "dzsinTCut", 0.5, "max dz sinTheta between ele and other tracks"};

m_elepTCut

Gaudi::Property<double> DerivationFramework::EGElectronAmbiguityTool::m_elepTCut

private

Initial value:

{
      this, "pTCut", 9000., "minimum pT for an electron to be studied"}

Definition at line 117 of file EGElectronAmbiguityTool.h.

                                    {
      this, "pTCut", 9000., "minimum pT for an electron to be studied"};

m_idCut

Gaudi::Property<std::string> DerivationFramework::EGElectronAmbiguityTool::m_idCut

private

Initial value:

{
      this, "idCut", "DFCommonElectronsLHLoose", "minimal quality for an electron to be studied"}

Definition at line 119 of file EGElectronAmbiguityTool.h.

                                    {
      this, "idCut", "DFCommonElectronsLHLoose", "minimal quality for an electron to be studied"};

m_isMC

Gaudi::Property<bool> DerivationFramework::EGElectronAmbiguityTool::m_isMC {this, "isMC", false}

private

Definition at line 114 of file EGElectronAmbiguityTool.h.

{this, "isMC", false};

m_meeAtVtxECCut

Gaudi::Property<double> DerivationFramework::EGElectronAmbiguityTool::m_meeAtVtxECCut

private

Initial value:

{
      this, "meeAtVtxCut", 100, "maximal mass at vertex to be classified as external conversion"}

Definition at line 137 of file EGElectronAmbiguityTool.h.

                                         {
      this, "meeAtVtxCut", 100, "maximal mass at vertex to be classified as external conversion"};

m_meeICCut

Gaudi::Property<double> DerivationFramework::EGElectronAmbiguityTool::m_meeICCut

private

Initial value:

{
      this, "meeCut", 100, "maximal mass at primary vertex to be classified as gamma*"}

Definition at line 139 of file EGElectronAmbiguityTool.h.

                                    {
      this, "meeCut", 100, "maximal mass at primary vertex to be classified as gamma*"};

m_nSiCut

Gaudi::Property<unsigned int> DerivationFramework::EGElectronAmbiguityTool::m_nSiCut

private

Initial value:

{
      this, "nSiCut", 7, "minimum number of Si hits in the other track"}

Definition at line 123 of file EGElectronAmbiguityTool.h.

                                        {
      this, "nSiCut", 7, "minimum number of Si hits in the other track"};

m_rvECCut

Gaudi::Property<double> DerivationFramework::EGElectronAmbiguityTool::m_rvECCut

private

Initial value:

{
      this, "radiusCut", 20, "minimum radius to be classified as external conversion"}

Definition at line 135 of file EGElectronAmbiguityTool.h.

                                   {
      this, "radiusCut", 20, "minimum radius to be classified as external conversion"};

m_sepCut

Gaudi::Property<double> DerivationFramework::EGElectronAmbiguityTool::m_sepCut

private

Initial value:

{
      this, "SeparationCut", 1., "first separation cut"}

Definition at line 127 of file EGElectronAmbiguityTool.h.

                                  {
      this, "SeparationCut", 1., "first separation cut"};

m_tpCName

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::EGElectronAmbiguityTool::m_tpCName

private

Initial value:

{
      this,
      "tpCName",
      "GSFTrackParticles",
      "SG key of TrackParticleInputContainer"
    }

Definition at line 59 of file EGElectronAmbiguityTool.h.

                                                         {
      this,
      "tpCName",
      "GSFTrackParticles",
      "SG key of TrackParticleInputContainer"
    };

m_tpContainerName

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::EGElectronAmbiguityTool::m_tpContainerName

private

Initial value:

{
      this,
      "tpContainerName",
      "InDetTrackParticles",
      "SG key of track particles container"
    }

Definition at line 52 of file EGElectronAmbiguityTool.h.

                                                                 {
      this,
      "tpContainerName",
      "InDetTrackParticles",
      "SG key of track particles container"
    };

m_VtxContainerName

SG::ReadHandleKey<xAOD::VertexContainer> DerivationFramework::EGElectronAmbiguityTool::m_VtxContainerName

private

Initial value:

{
      this,
      "VtxContainerName",
      "PrimaryVertices",
      "SG key of vertex container"
    }

Definition at line 46 of file EGElectronAmbiguityTool.h.

                                                           {
      this,
      "VtxContainerName",
      "PrimaryVertices",
      "SG key of vertex container"
    };

---

The documentation for this class was generated from the following files:

• EGElectronAmbiguityTool.h
• EGElectronAmbiguityTool.cxx