EMConversionBuilder Class Reference

EMConversion data object builder. More...

#include <EMConversionBuilder.h>

Inheritance diagram for EMConversionBuilder:

Collaboration diagram for EMConversionBuilder:

Public Member Functions
	EMConversionBuilder (const std::string &type, const std::string &name, const IInterface *parent)
	Default constructor.
virtual	~EMConversionBuilder ()=default
	Destructor.
StatusCode	initialize () override final
	initialize method
virtual StatusCode	executeRec (const EventContext &ctx, egammaRec *egRec) const override final
	execute method
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool interface methods.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	vertexExecute (const EventContext &ctx, egammaRec *egRec, const xAOD::VertexContainer *conversions) const
	actual implementation method
bool	passPtAndEoverP (const EventContext &ctx, const xAOD::Vertex &, const xAOD::CaloCluster &) const
	Return true if vertex and cluster pass Pt and E/p cuts.
float	getMaxTRTTubeHitFraction (const xAOD::Vertex &vertex) const
	Return the maximum fraction of TRT tube hits among the tracks.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< xAOD::VertexContainer >	m_conversionContainerKey
	Name of conversion container.
ToolHandle< IEMExtrapolationTools >	m_extrapolationTool
	EMExtrapolationTools.
Gaudi::Property< bool >	m_rejectAllTRT
	Ignore all conversion vertices that contain exclusively TRT-only tracks.
Gaudi::Property< int >	m_minTRTHits
	minimum number of TRT hits for TRT-only tracks (both single and double track conversion vertices)
Gaudi::Property< float >	m_minPt_singleTrack
	minimum pT for single-track conversion vertices
Gaudi::Property< float >	m_minPt_singleTRT
	minimum pT for TRT-only single-track conversion vertices
Gaudi::Property< float >	m_minTRTonlyTrackPt
	minimum pT for each track in TRT-only double-track conversion vertices
Gaudi::Property< float >	m_minSumPt_double
	minimum sum pT for double track conversion vertices
Gaudi::Property< float >	m_minSumPt_doubleTRT
	minimum sum pT for double TRT track conversion vertices
Gaudi::Property< float >	m_maxEoverP_singleTrack
	maximum E/p for single track conversion vertices (E is not calibrated)
Gaudi::Property< float >	m_maxEoverP_singleTrack_EtSf
	Scale maxEoverP_singleTrack by 1+sf*Et(cluster)/GeV.
Gaudi::Property< float >	m_maxTRTTubeHitFraction
	"Maximum fraction of tube hits for vertices with TRT tracks
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

EMConversion data object builder.

This is an Algorithm class. Selects conversion vertices reconstructed by the ID software after matching them to an EM calorimeter cluster. For normal two-track conversions the original photon track parameters at the conversion vertex are reconstructed. It is then extrapolated to the calorimeter and checked whether it matches the cluster. For single-track conversions, the reconstructed electron track is extrapolated to the calorimeter. A TrackToCalo extrapolation tool that can handle both neutral and charged track parameters (using a Trk::ParametersBase interface) is used throughout. The extrapolation starts at the last track measurement. Matching is done in both eta and phi. The eta matching WAS disabled for TRT-only tracks due to lack of accurate eta prediction BEFORE 12/2011.

Author

D. Zerwas

changes: June 16, 2010 (JM) bring some stuff from PhotonRecoveryTool here Mar, 2014 (BL) xAOD migration and new logic 2020 Athena Mt migration.

Definition at line 42 of file EMConversionBuilder.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

EMConversionBuilder()

EMConversionBuilder::EMConversionBuilder	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Default constructor.

Definition at line 77 of file EMConversionBuilder.cxx.

  : AthAlgTool(type, name, parent)
{
 
  // declare interface
  declareInterface<IEMConversionBuilder>(this);
}

~EMConversionBuilder()

virtual EMConversionBuilder::~EMConversionBuilder ( )

virtualdefault

Destructor.

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

executeRec()

StatusCode EMConversionBuilder::executeRec ( const EventContext & ctx, egammaRec * egRec ) const

finaloverridevirtual

execute method

Implements IEMConversionBuilder.

Definition at line 106 of file EMConversionBuilder.cxx.

{
  // retrieve Conversion Container
 
  SG::ReadHandle<xAOD::VertexContainer> conversions(m_conversionContainerKey,
                                                    ctx);
 
  // only for serial running; remove for MT
  ATH_CHECK(conversions.isValid());
  // reset the vertices
  std::vector<ElementLink<xAOD::VertexContainer>> vertices;
  egRec->setVertices(vertices);
  ATH_CHECK(vertexExecute(ctx, egRec, conversions.cptr()));
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getMaxTRTTubeHitFraction()

float EMConversionBuilder::getMaxTRTTubeHitFraction ( const xAOD::Vertex & vertex ) const

private

Return the maximum fraction of TRT tube hits among the tracks.

Definition at line 217 of file EMConversionBuilder.cxx.

{
  auto getTRTTubeHitFraction = [](const xAOD::TrackParticle* trk) {
    uint8_t nTRT;
    uint8_t nTRTTube;
    if (!trk || !trk->summaryValue(nTRT, xAOD::numberOfTRTHits) || !nTRT)
      return 0.;
    return trk->summaryValue(nTRTTube, xAOD::numberOfTRTTubeHits)
             ? 1. * nTRTTube / nTRT
             : 0.;
  };
 
  float maxTubeHitFraction = 0.;
  for (unsigned int i = 0; i < vertex.nTrackParticles(); ++i) {
    if (!vertex.trackParticle(i)) {
      ATH_MSG_WARNING("NULL pointer to track particle in conversion vertex");
    } else {
      float tubeHitFraction = getTRTTubeHitFraction(vertex.trackParticle(i));
      if (tubeHitFraction > maxTubeHitFraction) {
        maxTubeHitFraction = tubeHitFraction;
      }
    }
  }
  return maxTubeHitFraction;
}

initialize()

StatusCode EMConversionBuilder::initialize ( )

finaloverridevirtual

initialize method

Implements IEMConversionBuilder.

Definition at line 88 of file EMConversionBuilder.cxx.

{
 
  ATH_MSG_DEBUG("Initializing EMConversionBuilder");
 
  ATH_CHECK(m_conversionContainerKey.initialize());
 
  // the extrapolation tool
  if (m_extrapolationTool.retrieve().isFailure()) {
    ATH_MSG_ERROR("Cannot retrieve extrapolationTool " << m_extrapolationTool);
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Retrieved extrapolationTool " << m_extrapolationTool);
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & IEMConversionBuilder::interfaceID ( )

inlinestaticinherited

AlgTool interface methods.

Definition at line 48 of file IEMConversionBuilder.h.

{
  return IID_IEMConversionBuilder;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

passPtAndEoverP()

bool EMConversionBuilder::passPtAndEoverP ( const EventContext & ctx, const xAOD::Vertex & vertex, const xAOD::CaloCluster & cluster ) const

private

Return true if vertex and cluster pass Pt and E/p cuts.

Definition at line 179 of file EMConversionBuilder.cxx.

{
  Amg::Vector3D momentum =
    m_extrapolationTool->getMomentumAtVertex(ctx, vertex);
  float pt = momentum.perp();
  float EoverP = cluster.e() / momentum.mag();
 
  auto convType = xAOD::EgammaHelpers::conversionType(&vertex);
  bool isSingle = (convType == singleTRT || convType == singleSi);
  bool isTRT =
    (convType == singleTRT || convType == xAOD::EgammaParameters::doubleTRT);
  float EoverPcut = m_maxEoverP_singleTrack *
                    (1 + m_maxEoverP_singleTrack_EtSf * cluster.et() * 1e-3);
 
  // Check TRT tube hit fraction
  float tubeHitFraction = getMaxTRTTubeHitFraction(vertex);
  if (isTRT && tubeHitFraction > m_maxTRTTubeHitFraction) {
    ATH_MSG_DEBUG("Conversion failed cut on TRT tube hit fraction: "
                  << tubeHitFraction << " vs. " << m_maxTRTTubeHitFraction);
    return false;
  }
 
  bool reject =
    ((isTRT && m_rejectAllTRT) || (isSingle && pt < m_minPt_singleTrack) ||
     (!isSingle && pt < m_minSumPt_double) ||
     (isSingle && EoverP > EoverPcut) ||
     (convType == singleTRT && pt < m_minPt_singleTRT) ||
     (convType == doubleTRT && pt < m_minSumPt_doubleTRT));
 
  if (reject) {
    ATH_MSG_DEBUG("Conversion failed pt or E/p cuts");
  }
  return !reject;
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

vertexExecute()

StatusCode EMConversionBuilder::vertexExecute ( const EventContext & ctx, egammaRec * egRec, const xAOD::VertexContainer * conversions ) const

private

actual implementation method

Definition at line 123 of file EMConversionBuilder.cxx.

{
 
  if (!egRec || !conversions) {
    ATH_MSG_WARNING(
      "trackExecute: NULL pointer to egammaRec or VertexContainer");
    return StatusCode::SUCCESS;
  }
 
  static const SG::AuxElement::Accessor<float> accetaAtCalo("etaAtCalo");
  static const SG::AuxElement::Accessor<float> accphiAtCalo("phiAtCalo");
 
  float etaAtCalo(0);
  float phiAtCalo(0);
  for (unsigned int iVtx = 0; iVtx < conversions->size(); ++iVtx) {
 
    const xAOD::Vertex* vertex = conversions->at(iVtx);
    // Check if vertex was already decorated with etaAtCalo, phiAtCalo
    if (accetaAtCalo.isAvailable(*vertex) &&
        accphiAtCalo.isAvailable(*vertex)) {
      etaAtCalo = accetaAtCalo(*vertex);
      phiAtCalo = accphiAtCalo(*vertex);
    }
    // check extrapolation, skip vertex in case of failure
    else if (!m_extrapolationTool->getEtaPhiAtCalo(
               ctx, vertex, &etaAtCalo, &phiAtCalo)) {
      continue;
    }
    const xAOD::CaloCluster* cluster = egRec->caloCluster();
    if (!passPtAndEoverP(ctx, *vertex, *cluster)) {
      continue;
    }
    if (!m_extrapolationTool->matchesAtCalo(
          cluster, vertex, etaAtCalo, phiAtCalo)) {
      continue;
    }
    const ElementLink<xAOD::VertexContainer> vertexLink(*conversions, iVtx, ctx);
 
    // If this is the best (or the first) vertex, push front and keep deltaEta,
    // deltaPhi
    if (!egRec->getNumberOfVertices() ||
        ConvVxSorter(*vertex, *egRec->vertex())) {
      egRec->pushFrontVertex(vertexLink);
      egRec->setDeltaEtaVtx(cluster->etaBE(2) - etaAtCalo);
      egRec->setDeltaPhiVtx(P4Helpers::deltaPhi(cluster->phiBE(2), phiAtCalo));
    } else { // Not the best vertex, push back
      egRec->pushBackVertex(vertexLink);
    }
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_conversionContainerKey

SG::ReadHandleKey<xAOD::VertexContainer> EMConversionBuilder::m_conversionContainerKey

private

Initial value:

{
    this,
    "ConversionContainerName",
    "PhotonConversionVertices",
    "Name of the input conversion container"
  }

Name of conversion container.

Definition at line 78 of file EMConversionBuilder.h.

                                                               {
    this,
    "ConversionContainerName",
    "PhotonConversionVertices",
    "Name of the input conversion container"
  };

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extrapolationTool

ToolHandle<IEMExtrapolationTools> EMConversionBuilder::m_extrapolationTool

private

Initial value:

{
    this,
    "ExtrapolationTool",
    "EMExtrapolationTools",
    "Handle of the extrapolation tool"
  }

EMExtrapolationTools.

Definition at line 86 of file EMConversionBuilder.h.

                                                       {
    this,
    "ExtrapolationTool",
    "EMExtrapolationTools",
    "Handle of the extrapolation tool"
  };

m_maxEoverP_singleTrack

Gaudi::Property<float> EMConversionBuilder::m_maxEoverP_singleTrack

private

Initial value:

{
    this,
    "maxEoverP_singleTrack",
    10.,
    "Maximum E/p for single track conversion vertices"
  }

maximum E/p for single track conversion vertices (E is not calibrated)

Definition at line 155 of file EMConversionBuilder.h.

                                              {
    this,
    "maxEoverP_singleTrack",
    10.,
    "Maximum E/p for single track conversion vertices"
  };

m_maxEoverP_singleTrack_EtSf

Gaudi::Property<float> EMConversionBuilder::m_maxEoverP_singleTrack_EtSf

private

Initial value:

{
    this,
    "maxEoverP_singleTrack_EtSf",
    0.01,
    "Scale maxEoverP_singleTrack by ( 1+sf*Et(cluster)/GeV )"
  }

Scale maxEoverP_singleTrack by 1+sf*Et(cluster)/GeV.

Definition at line 163 of file EMConversionBuilder.h.

                                                   {
    this,
    "maxEoverP_singleTrack_EtSf",
    0.01,
    "Scale maxEoverP_singleTrack by ( 1+sf*Et(cluster)/GeV )"
  };

m_maxTRTTubeHitFraction

Gaudi::Property<float> EMConversionBuilder::m_maxTRTTubeHitFraction

private

Initial value:

{
    this,
    "maxTRTTubeHitFraction",
    999.,
    "Maximum fraction of tube hits for vertices with TRT tracks"
  }

"Maximum fraction of tube hits for vertices with TRT tracks

Definition at line 171 of file EMConversionBuilder.h.

                                              {
    this,
    "maxTRTTubeHitFraction",
    999.,
    "Maximum fraction of tube hits for vertices with TRT tracks"
  };

m_minPt_singleTrack

Gaudi::Property<float> EMConversionBuilder::m_minPt_singleTrack

private

Initial value:

{
    this,
    "minPt_singleTrack",
    0 * Gaudi::Units::GeV,
    "minimum pT for single-track conversion vertices"
  }

minimum pT for single-track conversion vertices

Definition at line 113 of file EMConversionBuilder.h.

                                          {
    this,
    "minPt_singleTrack",
    0 * Gaudi::Units::GeV,
    "minimum pT for single-track conversion vertices"
  };

m_minPt_singleTRT

Gaudi::Property<float> EMConversionBuilder::m_minPt_singleTRT

private

Initial value:

{
    this,
    "minPt_singleTRT",
    2 * Gaudi::Units::GeV,
    "minimum pT for TRT-only single-track conversion vertices"
  }

minimum pT for TRT-only single-track conversion vertices

Definition at line 121 of file EMConversionBuilder.h.

                                        {
    this,
    "minPt_singleTRT",
    2 * Gaudi::Units::GeV,
    "minimum pT for TRT-only single-track conversion vertices"
  };

m_minSumPt_double

Gaudi::Property<float> EMConversionBuilder::m_minSumPt_double

private

Initial value:

{
    this,
    "minSumPt_double",
    0 * Gaudi::Units::GeV,
    "minimum sum pT for double track conversion vertices"
  }

minimum sum pT for double track conversion vertices

Definition at line 138 of file EMConversionBuilder.h.

                                        {
    this,
    "minSumPt_double",
    0 * Gaudi::Units::GeV,
    "minimum sum pT for double track conversion vertices"
  };

m_minSumPt_doubleTRT

Gaudi::Property<float> EMConversionBuilder::m_minSumPt_doubleTRT

private

Initial value:

{
    this,
    "minSumPt_doubleTRT",
    2 * Gaudi::Units::GeV,
    "minimum sum pT for double TRT track conversion vertices"
  }

minimum sum pT for double TRT track conversion vertices

Definition at line 146 of file EMConversionBuilder.h.

                                           {
    this,
    "minSumPt_doubleTRT",
    2 * Gaudi::Units::GeV,
    "minimum sum pT for double TRT track conversion vertices"
  };

m_minTRTHits

Gaudi::Property<int> EMConversionBuilder::m_minTRTHits

private

Initial value:

{
    this,
    "minTRTHits",
    0,
    "minimum number of TRT hits for TRT-only tracks (both single and double "
    "track conversion vertices)"
  }

minimum number of TRT hits for TRT-only tracks (both single and double track conversion vertices)

Definition at line 104 of file EMConversionBuilder.h.

                                 {
    this,
    "minTRTHits",
    0,
    "minimum number of TRT hits for TRT-only tracks (both single and double "
    "track conversion vertices)"
  };

m_minTRTonlyTrackPt

Gaudi::Property<float> EMConversionBuilder::m_minTRTonlyTrackPt

private

Initial value:

{
    this,
    "minTRTonlyTrackPt",
    0 * Gaudi::Units::GeV,
    "minimum pT for each track in TRT-only double-track conversion vertices"
  }

minimum pT for each track in TRT-only double-track conversion vertices

Definition at line 130 of file EMConversionBuilder.h.

                                          {
    this,
    "minTRTonlyTrackPt",
    0 * Gaudi::Units::GeV,
    "minimum pT for each track in TRT-only double-track conversion vertices"
  };

m_rejectAllTRT

Gaudi::Property<bool> EMConversionBuilder::m_rejectAllTRT

private

Initial value:

{
    this,
    "RejectAllTRTConversions",
    false,
    "Ignore all conversion vertices containing exclusively TRT-only tracks"
  }

Ignore all conversion vertices that contain exclusively TRT-only tracks.

Definition at line 95 of file EMConversionBuilder.h.

                                    {
    this,
    "RejectAllTRTConversions",
    false,
    "Ignore all conversion vertices containing exclusively TRT-only tracks"
  };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• EMConversionBuilder.h
• EMConversionBuilder.cxx