#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 83 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 243 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 47 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 Function 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.

◆ m_dambi

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

private

Definition at line 83 of file EGElectronAmbiguityTool.h.

◆ 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.

◆ m_dmee

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

private

Definition at line 74 of file EGElectronAmbiguityTool.h.

◆ m_dmeeVtx

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

private

Definition at line 77 of file EGElectronAmbiguityTool.h.

◆ m_dphiv

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

private

Definition at line 71 of file EGElectronAmbiguityTool.h.

◆ m_drv

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

private

Definition at line 68 of file EGElectronAmbiguityTool.h.

◆ m_dsep

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

private

Definition at line 80 of file EGElectronAmbiguityTool.h.

◆ m_dtpv

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

private

Definition at line 89 of file EGElectronAmbiguityTool.h.

◆ m_dtrv

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

private

Definition at line 86 of file EGElectronAmbiguityTool.h.

◆ m_dtzv

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

private

Definition at line 92 of file EGElectronAmbiguityTool.h.

◆ 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.

◆ 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.

◆ 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.

◆ m_isMC

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

private

Definition at line 114 of file EGElectronAmbiguityTool.h.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Function Documentation

◆ addBranches()

◆ decorateSimple()

◆ initialize()

Friends And Related Function Documentation

◆ DecorHandles

Member Data Documentation

◆ m_containerName

◆ m_dambi

◆ m_dctCut

◆ m_dmee

◆ m_dmeeVtx

◆ m_dphiv

◆ m_drv

◆ m_dsep

◆ m_dtpv

◆ m_dtrv

◆ m_dtzv

◆ m_dzCut

◆ m_elepTCut

◆ m_idCut

◆ m_isMC

◆ m_meeAtVtxECCut

◆ m_meeICCut

◆ m_nSiCut

◆ m_rvECCut

◆ m_sepCut

◆ m_tpCName

◆ m_tpContainerName

◆ m_VtxContainerName