DerivationFramework::EGElectronAmbiguityTool Class Reference

#include <EGElectronAmbiguityTool.h>

Inheritance diagram for DerivationFramework::EGElectronAmbiguityTool:

Collaboration diagram for DerivationFramework::EGElectronAmbiguityTool:

Classes
struct	DecorHandles

Public Member Functions
	EGElectronAmbiguityTool (const std::string &t, const std::string &n, const IInterface *p)
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", "", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dphiv { this, "DFCommonSimpleConvPhi", "", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dmee { this, "DFCommonSimpleMee", "", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dmeeVtx { this, "DFCommonSimpleMeeAtVtx", "", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dsep { this, "DFCommonSimpleSeparation", "", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dambi { this, "DFCommonAddAmbiguity", "", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dtrv { this, "DFCommonProdTrueRadius", "", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dtpv { this, "DFCommonProdTruePhi", "", "" }
SG::WriteDecorHandleKey< xAOD::ElectronContainer >	m_dtzv { this, "DFCommonProdTrueZ", "", "" }
bool	m_isMC {}
double	m_elepTCut
std::string	m_idCut
unsigned int	m_nSiCut
double	m_dctCut
double	m_sepCut
double	m_dzCut
double	m_rvECCut
double	m_meeAtVtxECCut
double	m_meeICCut

Friends
struct	DecorHandles

Detailed Description

Definition at line 33 of file EGElectronAmbiguityTool.h.

Constructor & Destructor Documentation

EGElectronAmbiguityTool()

DerivationFramework::EGElectronAmbiguityTool::EGElectronAmbiguityTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 52 of file EGElectronAmbiguityTool.cxx.

  : base_class(t, n, p)
{
 
  declareProperty("isMC", m_isMC);
 
  declareProperty(
    "pTCut", m_elepTCut = 9e3, "minimum pT for an electron to be studied");
  declareProperty("idCut",
                  m_idCut = "DFCommonElectronsLHLoose",
                  "minimal quality for an electron to be studied");
 
  declareProperty(
    "nSiCut", m_nSiCut = 7, "minimum number of Si hits in the other track");
  declareProperty(
    "dzsinTCut", m_dzCut = 0.5, "max dz sinTheta between ele and other tracks");
  declareProperty("SeparationCut", m_sepCut = 1., "first separation cut");
  declareProperty("DCTCut", m_dctCut = 0.02, "second separation cut");
 
  declareProperty("radiusCut",
                  m_rvECCut = 20,
                  "minimum radius to be classified as external conversion");
  declareProperty(
    "meeAtVtxCut",
    m_meeAtVtxECCut = 100,
    "maximal mass at vertex to be classified as external conversion");
  declareProperty("meeCut",
                  m_meeICCut = 100,
                  "maximal mass at primary vertex to be classified as gamma*");
}

Member Function Documentation

addBranches()

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

finaloverridevirtual

Definition at line 133 of file EGElectronAmbiguityTool.cxx.

{
 
  DecorHandles dh (*this, ctx);
 
  static const SG::AuxElement::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()) * 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 293 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()) * 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 = TMath::PiOver2() - helix1[4];
    else
      beta = TMath::PiOver2() - helix2[4];
 
    double phi1(helix1[4] + beta);
    if (phi1 > TMath::TwoPi())
      phi1 -= TMath::TwoPi();
    if (phi1 < 0.)
      phi1 += TMath::TwoPi();
 
    double phi2(helix2[4] + beta);
    if (phi2 > TMath::TwoPi())
      phi2 -= TMath::TwoPi();
    if (phi2 < 0.)
      phi2 += TMath::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 + TMath::PiOver2() * charge1);
 
    double x1 = rcenter1 * cos(phicenter1);
    double y1 = rcenter1 * 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 + TMath::PiOver2() * charge2);
 
    double x2 = rcenter2 * cos(phicenter2);
    double y2 = rcenter2 * sin(phicenter2);
 
    double dx(x1 - x2);
    if (dx < 1e-9 && dx > 0.)
      dx = 1e-9;
    if (dx > -1e-9 && dx < 0.)
      dx = -1e-9;
    double slope((y1 - y2) / dx);
    double b(y1 - slope * x1);
    double alpha(atan(slope));
    double d(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 * cos(alpha);
      cpx2 = x2 + r2 * cos(alpha);
    } else {
      cpx1 = x1 + r1 * cos(alpha);
      cpx2 = x2 - r2 * cos(alpha);
    }
 
    double temp1 = (cpx1 + cpx2) / 2;
    double temp2 = slope * temp1 + b;
    double convX = cos(beta) * temp1 + sin(beta) * temp2;
    double convY = -sin(beta) * temp1 + 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 = sqrt(convX * convX + convY * convY);
      if (convX * cos(eletrkP->phi()) + convY * 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 86 of file EGElectronAmbiguityTool.cxx.

{
 
  ATH_CHECK(m_containerName.initialize());
  ATH_CHECK(m_VtxContainerName.initialize());
  ATH_CHECK(m_tpContainerName.initialize());
  ATH_CHECK(m_tpCName.initialize());
 
  const std::string baseName = m_containerName.key();
  m_drv = baseName + ".DFCommonSimpleConvRadius";
  m_dphiv = baseName + ".DFCommonSimpleConvPhi";
  m_dmee = baseName + ".DFCommonSimpleMee";
  m_dmeeVtx = baseName + ".DFCommonSimpleMeeAtVtx";
  m_dsep = baseName + ".DFCommonSimpleSeparation";
  m_dambi = baseName + ".DFCommonAddAmbiguity";
  m_dtrv = baseName + ".DFCommonProdTrueRadius";
  m_dtpv = baseName + ".DFCommonProdTruePhi";
  m_dtzv = baseName + ".DFCommonProdTrueZ";
 
  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 Function Documentation

DecorHandles

friend struct DecorHandles

friend

Definition at line 111 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 45 of file EGElectronAmbiguityTool.h.

m_dambi

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

private

Definition at line 88 of file EGElectronAmbiguityTool.h.

m_dctCut

double DerivationFramework::EGElectronAmbiguityTool::m_dctCut

private

Definition at line 127 of file EGElectronAmbiguityTool.h.

m_dmee

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

private

Definition at line 79 of file EGElectronAmbiguityTool.h.

m_dmeeVtx

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

private

Definition at line 82 of file EGElectronAmbiguityTool.h.

m_dphiv

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

private

Definition at line 76 of file EGElectronAmbiguityTool.h.

m_drv

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

private

Definition at line 73 of file EGElectronAmbiguityTool.h.

m_dsep

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

private

Definition at line 85 of file EGElectronAmbiguityTool.h.

m_dtpv

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

private

Definition at line 94 of file EGElectronAmbiguityTool.h.

m_dtrv

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

private

Definition at line 91 of file EGElectronAmbiguityTool.h.

m_dtzv

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

private

Definition at line 97 of file EGElectronAmbiguityTool.h.

m_dzCut

double DerivationFramework::EGElectronAmbiguityTool::m_dzCut

private

Definition at line 127 of file EGElectronAmbiguityTool.h.

m_elepTCut

double DerivationFramework::EGElectronAmbiguityTool::m_elepTCut

private

Definition at line 122 of file EGElectronAmbiguityTool.h.

m_idCut

std::string DerivationFramework::EGElectronAmbiguityTool::m_idCut

private

Definition at line 123 of file EGElectronAmbiguityTool.h.

m_isMC

bool DerivationFramework::EGElectronAmbiguityTool::m_isMC {}

private

Definition at line 119 of file EGElectronAmbiguityTool.h.

m_meeAtVtxECCut

double DerivationFramework::EGElectronAmbiguityTool::m_meeAtVtxECCut

private

Definition at line 132 of file EGElectronAmbiguityTool.h.

m_meeICCut

double DerivationFramework::EGElectronAmbiguityTool::m_meeICCut

private

Definition at line 132 of file EGElectronAmbiguityTool.h.

m_nSiCut

unsigned int DerivationFramework::EGElectronAmbiguityTool::m_nSiCut

private

Definition at line 126 of file EGElectronAmbiguityTool.h.

m_rvECCut

double DerivationFramework::EGElectronAmbiguityTool::m_rvECCut

private

Definition at line 132 of file EGElectronAmbiguityTool.h.

m_sepCut

double DerivationFramework::EGElectronAmbiguityTool::m_sepCut

private

Definition at line 127 of file EGElectronAmbiguityTool.h.

m_tpCName

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

private

Initial value:

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

Definition at line 64 of file EGElectronAmbiguityTool.h.

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 57 of file EGElectronAmbiguityTool.h.

m_VtxContainerName

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

private

Initial value:

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

Definition at line 51 of file EGElectronAmbiguityTool.h.

---

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

• EGElectronAmbiguityTool.h
• EGElectronAmbiguityTool.cxx