Block filler tool for noisy FEB information. More...

Namespaces
namespace	Root

Classes
class	CaloCellDetailsFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	CaloCellRawFillerTool
	Block filler tool for calo cell raw eta/phi. More...
class	CaloClusterCellAssociationTool
	Associate from a CaloCluster to CaloCell. More...
class	ClusterEMSamplingFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	ClusterPositionInCaloFillerTool
	Block filler tool for eta/phi positions in calo coordinate from a CaloCluster. More...
class	ClusterSamplingFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	LArCollisionTimeFillerTool
	Block filler tool for collision time information. More...
class	MBTSFillerTool
	Block filler tool for MBTS information. More...
class	MBTSTimeFillerTool
	Block filler tool for combined MBTS time information. More...
class	CaloCalibrationHitContainerGetterTool
	define a special getter More...
class	CaloCalibHitFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	CaloInfoFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	LArDigitFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	LArHitContainerGetterTool
	define a special getter More...
class	LArHitFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	LArNoisyROFillerTool
class	LArRawChannelContainerGetterTool
class	LArRawChannelFillerTool
class	LArSCHitFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	SCFillerTool
	Block filler tool for EM samplings from a CaloCluster. More...
class	SGTileDigitsGetterTool
class	SGTileHitGetterTool
class	SGTileModuleBitsGetterTool
class	SGTileRawChannelGetterTool
class	TileCellDetailsFillerTool
class	TileCellDigitAssociationTool
class	TileCellRawAssociationTool
class	TileCosmicMuonFillerTool
class	TileCosmicMuonTileCellAssociationTool
class	TileDigitFillerTool
class	TileHitFillerTool
class	TileHitInfoFillerTool
	Block filler tool for total TileHit energy. More...
class	TileL2FillerTool
class	TileModuleBitsFillerTool
class	TileMuFillerTool
class	TileRawChannelFillerTool
class	TileTriggerFillerTool
class	TileTTL1FillerTool
class	TowerFillerTool
class	AuxDataFillerTool
	Copy aux data to D3PD. More...
class	CollectionGetterRegistryTool
	Tool to keep a registry of collection getter tools. More...
class	ContainedAssociationFillerTool
	Represent a single association by containment. More...
class	ContainedMultiAssociationFillerTool
	Represent a multiple association by containment. More...
class	ContainerFlagFillerTool
	Flag objects that are present in other containers. More...
class	DummyInitAlg
	Work around initialization ordering problems. More...
class	DummyVarFillerTool
	Create an empty variable in the D3PD. More...
class	FirstAssociationTool
	Choose the first result from a multiple association. More...
class	IdentityAssociationTool
	A generic identity association; i.e., one that simply returns its input. More...
class	IndexFillerTool
	Fill an index of an object within a container. More...
class	MakerAlg
	Algorithm to create a D3PD tree. More...
class	ObjFillerTool
	Object filler tool for a single object. More...
class	SelectedParticlesFilterTool
	A collection getter that filters the results of another based on the contents of a `SelectedParticles` object. More...
class	SGDataVectorGetterTool
	Getter tool to retrieve DataVector/List collections from StoreGate. More...
class	SGObjGetterTool
	Getter tool to retrieve single objects from StoreGate. More...
class	VoidObjFillerTool
	Object filler tool for tools taking no input. More...
class	IAddVariable
	Common interface for adding a variable to a tuple. More...
class	ICollectionGetterRegistryTool
	Abstract interface to keep a registry of collection getter tools. More...
class	ICollectionGetterTool
	Abstract interface to get a collection of objects and iterate over it. More...
class	ID3PD
	Define an abstract interface for building a D3PD tree. More...
class	ID3PDSvc
	Abstract interface for service to create D3PD trees. More...
class	IIteration
	Abstract interface for iterating over a set of things. More...
class	IMetadataTool
	Write metadata to a D3PD. More...
class	IMultiAssociationTool
	Abstract interface to form a multi-way association. More...
class	IObjGetterTool
	Abstract interface to get an object to put in the tuple. More...
class	ISingleAssociationTool
	Abstract interface to form a single association. More...
class	FakeProxy
	Proxy class for storing any kind of object. More...
class	RootD3PD
	Root-based D3PD tree. More...
class	RootD3PDSvc
	Service to create a root-based D3PD. More...
class	AddVariable
	Common implementation of `IAddVariable`. More...
class	BlockFillerTool
	Type-safe wrapper for block filler tools. More...
class	BlockFillerToolImpl
	Non-template parts of `BlockFillerTool`. More...
class	BlockFillerTool< Types< T0 > >
	A specialization of BlockFillerTool that can accept one of several types. More...
class	CollectionGetterFilterTool
	A collection getter that filters the results of another. More...
class	CollectionGetterFilterToolImpl
	Non-template parts of `CollectionGetterFilterTool`. More...
class	CollectionGetterTool
	Type-safe wrapper for `ICollectionGetterTool`. More...
class	CollectionGetterToolImpl
	Non-template parts of `CollectionGetterTool`. More...
class	IndexMap
class	MultiAssociationToolTo
	Helper for `MultiAssociationTool`. More...
class	MultiAssociationTool
	Type-safe wrapper for multiple-target associator tools. More...
class	MultiAssociationToolImpl
	Non-template parts of `MultiAssociationTool`. More...
class	MultiAssociationTool< Types< T0 >, TO_T >
	A specialization of MultiAssociationTool that can accept one of several types. More...
class	MultiAssociationTool< Types< T0 >, Types< U0 > >
	A specialization of MultiAssociationTool that can accept one of several types, mapping to multiple output types. More...
class	ObjectMetadata
	D3PD variable metadata handling class. More...
class	ObjGetterTool
	This is a type-safe wrapper for the `IObjGetterTool` interface. More...
class	ObjGetterToolImpl
	Non-template parts of `ObjGetterTool`. More...
class	SGCollectionGetterTool
	Collection getter tool retrieving a container from StoreGate. More...
class	SGGetterImpl
	Common object getter code for retrieving from StoreGate. More...
class	SGKeyResolver
	Helper to resolve the SG key to use. More...
class	SingleAssociationToolTo
	Helper for `SingleAssociationTool`. More...
class	SingleAssociationTool
	Type-safe wrapper for single associator tools. More...
class	SingleAssociationToolImpl
	Non-template parts of `SingleAssociationTool`. More...
class	SingleAssociationTool< Types< T0 >, TO_T >
	A specialization of SingleAssociationTool that can accept one of several types. More...
class	TypeConverter
	This is helper for converting between pointers of different types, given dynamically by `std::type_info`. More...
class	NoType
	Placeholder for empty type. More...
struct	WrapType
	Helper so that Types<> will be an empty class. More...
struct	SelectType
	Select one type out of the tuple. More...
struct	SelectType< Types< TYPES... >, N >
	SelectType used of Types. More...
struct	ButFirstType
struct	ButFirstType< Types< T0, TYPES... > >
class	Var
	Description for a single variable. More...
struct	Vars
	Description for the list of variables. More...
class	BlockFillerTool< void >
	Type-safe wrapper for block filler tools, for tools taking no input. More...
class	egammaDeltaEmax2Alg
	Calculate deltaEmax2 for egamma objects and store as UD. More...
class	egammaMaxECellAlg
	Find most energetic cell in the middle layer for an egamma object and store in UserData. More...
class	egammaNbCellsGainAlg
	Count the number of cells in each gain, layer by layer. More...
class	egammaSumCellsGainAlg
	Find most energetic cell in the middle layer for an egamma object and store in UserData. More...
class	egammaTruthAlg
	Select egtruth particles. More...
class	PhotonTruthAlg
	Analyze GenParticle's matching photons and made UD decorations. More...
class	PhotonTruthTool
class	ConversionVertexAssociationTool
	Associate from a conversion to its vertex. More...
class	egammaClusterAssociationTool
	Associate from an egamma to its CaloCluster. More...
class	egammaConversion0FillerTool
	Block filler tool for photon conversion information, for LOD 0. More...
class	egammaConversionFillerTool
	Block filler tool for photon conversion information. More...
class	egammaGenParticleAssociationTool
	Associate from an electron/photon to a matched GenParticle via classification tool. More...
class	egammaLayer1ExtraFillerTool
class	egammaRetaphiFillerTool
class	egammaTraversedMaterialFillerTool
	Block filler tool for the material traversed by a photon/electron until the entrance of the calorimeter (in X0). More...
class	egammaTruthClassificationFillerTool
	Fill in type/origin from MC classifier tool for an egamma. More...
class	ElectronJetDRAssociator
	For every electron find jets in a cone and store lifetime, signed IP, and PTRel of relation. More...
class	ElectronTrackParticleAssociationTool
	Associate from an egamma to its TrackParticle. More...
class	DRConeAssociationTool
	Associate all particles within a DR cut. More...
class	EventErrorStateFillerTool
	Block filler tool for event error state from `EventInfo`. More...
struct	EventFlagNames
class	EventTrigInfoFillerTool
	Tool writing the stream decisions to D3PDs. More...
class	EventTypeFillerTool
	Block filler tool for the event type from `EventInfo`. More...
class	EventWeightFillerTool
	Block filler tool for the event weight from `EventInfo`. More...
class	FourMomFillerTool
	Block filler tool for a four-momentum. More...
class	INav4MomLinkContainerGetterTool
	Getter tool to retrieve an `INav4MomLinkContainer` from SG. More...
class	IParticleLinksCollectionGetterTool
class	LBMetadataTool
	Add luminosity metadata info to a D3PD. More...
class	SkimDecisionFillerTool
	Block filler tool for SkimDecisions. More...
class	MDTSimHitFillerTool
	Filler tool for the basic properties of MDTSimHit. More...
class	MuonGenParticleAssociationTool
	Associate from an electron/photon to a matched GenParticle via classification tool. More...
class	MuonNumberOfSegmentsFillerTool
	Fill number of muon segments. More...
class	MuonTrackParticleAssociationTool
	Associate from an Muon to its primary TrackParticle. More...
class	MuonTrkHitFillerTool
class	MuonTruthClassificationFillerTool
class	MuonTruthHitsFillerTool
	Fill truth hit information for muons. More...
class	TrackRecordCollectionGetterTool
class	TrackRecordFillerTool
	Filler tool for the basic properties of TrackRecord. More...
class	TruthMuonsToSG
class	TileAssocFillerTool
class	TileCellFillerTool
class	TileClusterFillerTool
class	TileEventFillerTool
class	TileMuonFillerTool
class	TileTrackFillerTool
class	CovarianceFillerTool
	Block filler tool for error and covariance matrix. More...
class	ImpactSigmaFillerTool
	Fill d0/z0 uncertainties from an ErrorMatrix. More...
class	PerigeeBLPredictionFillerTool
	Fill expectHitInBLayer from a Perigee. More...
class	PerigeeCovarianceAssociationTool
	Associate from a Perigee to its ErrorMatrix. More...
class	PerigeeFillerTool
class	PerigeePairOldPerigeeAssociationTool
	Associate from a PerigeePair to the perigee for the original track. More...
class	TrackParticleChargeFillerTool
class	TrackParticlePerigeeAtBSAssociationTool
	Associate from a VxCandidate to its perigee at the beam spot. More...
class	TrackParticlePerigeeAtOOAssociationTool
	Associate from a TrackParticle to its default Perigee. More...
class	TrackParticlePerigeeAtPVAssociationTool
	Associate from a VxCandidate to its perigee at primary vertex. More...
class	TrackParticlePerigeePairAtOOAssociationTool
	Associate from a VxCandidate to its Position ErrorMatrix. More...
class	TrackParticleVertexAssociationTool
	Associate from a TrackParticle to its reconstructed vertex. More...
class	VertexCovarianceAssociationTool
	Associate from a VxCandidate to its Position ErrorMatrix. More...
class	VertexKineFillerTool
	Block filler tool for vertex kinematics, from attached tracks. More...
class	VertexTrackParticleAssociationTool
struct	PerigeePair
class	D3PDMCTruthClassifier
	Work around MCTruthClassifier brain-damage. More...
class	TruthParticleBremFillerTool
	Fill the hasHardBrem flag. More...
class	TruthParticleChildAssociationTool
	Associate all particles within a DR cut. More...
class	TruthParticleClassificationFillerTool
class	TruthParticleFillerTool
class	TruthParticleParentAssociationTool
	Associate all particles within a DR cut. More...
class	TruthParticleProdVertexAssociationTool
	Associate from a TruthParticle to its GenVertex production vertex. More...

Typedefs
template<class... TYPES>
using	Types = std::tuple<WrapType<TYPES>...>
	A simple tuple of multiple types.
template<class T>
using	ButFirstType_t = typename ButFirstType<T>::type

Functions
StatusCode	scout (EMPTY)
	Fill one block.
	if (pout)
m_associator	releaseObjectUntyped (pout)
return	againok (scout)
	for (size_t i=0;i< m_blockFillers.size();i++)
	Fill one block.
m_associator	releaseElementUntyped (m_next)
	if (m_next\|\|!again) return StatusCode(AGAIN)
	CHECK (doFill(*m_associator, 0))
	Fill one block.
	ContainedVectorMultiAssociationFillerTool (const std::string &type, const std::string &name, const IInterface *parent)
	Represent a multiple association by containment inside vectors.
virtual StatusCode	initialize ()
	Standard Gaudi `initialize` method.
virtual StatusCode	configureD3PD (IAddVariable *tree, const std::type_info &ti)
	Configure during initialization: type-check.
virtual StatusCode	book ()
	Declare tuple variables.
StatusCode DummyInitAlg::initialize	ATLAS_NOT_THREAD_SAFE ()
	Standard Gaudi `initialize` method.
	if (m_index) *m_index
	Fill one block.
	IndexAssociationFillerTool (const std::string &type, const std::string &name, const IInterface *parent)
	Represent a single association by index.
	CHECK (m_associator->resetUntyped(p))
	Fill one block.
	while (const void *pout=m_associator->nextUntyped())
	IndexMultiAssociationFillerTool (const std::string &type, const std::string &name, const IInterface *parent)
	Represent a multiple association by index.
	VectorFillerTool (const std::string &type, const std::string &name, const IInterface *parent)
	Object filler tool for a collection of objects, saved as vectors.
virtual StatusCode	configureD3PD (IAddVariable *tree)
	Configure the tool.
virtual StatusCode	fill ()
	Fill one object.
virtual bool	isContainerFiller () const
	Find out if the filler handles containers or single objects.
virtual void	handle (const Incident &inc)
	Handle end of run incidents to save the metadata at that point.
static StatusCode	againok (StatusCode sc)
	Fill one block.
static StatusCode	againok (StatusCode sc, StatusCode &scout)
	StatusCode check helper: change `AGAIN` or `EMPTY` to `SUCCESS`.
ObjectMetadata	operator+ (const ObjectMetadata &obj1, const ObjectMetadata &obj2)
	Operator for creating the sum of two metadata objects.
StatusCode	nameToTypeinfo (const std::string &name, std::type_info const *&ti, const std::string &context, const ServiceHandle< IClassIDSvc > &clidsvc=ServiceHandle< IClassIDSvc >("ClassIDSvc", "TypeNameConversions"))
	Convert from a class name to a type_info.
StatusCode	nameToCLID (const std::string &name, CLID &clid, const std::string &context, const ServiceHandle< IClassIDSvc > &clidsvc=ServiceHandle< IClassIDSvc >("ClassIDSvc", "TypeNameConversions"))
	Convert from a class name to a CLID.
StatusCode	clidToTypeinfo (CLID clid, const std::string &name, std::type_info const *&ti, const std::string &context)
	Convert from a CLID to a type_info; we also already know the name.
std::string	typeinfoToName (const std::type_info &ti)
	Convert from a type_info to a name.
template<class T0>
const std::type_info &	multiTypeInfo (Types< T0 > *, size_t which)
	Return one `type_info` from a tuple.
template<class T0, class... TYPES>
const std::type_info &	multiTypeInfo (Types< T0, TYPES... > *, size_t which)
template<class T>
const std::type_info &	multiTypeInfo (T *, size_t)
	VectorFillerToolBase (const std::string &type, const std::string &name, const IInterface *parent)
	Common code for wrapping filled variables up into a vector.
virtual StatusCode	finalize ()
	Standard Gaudi `finalize` method.
virtual StatusCode	addVariable (const std::string &name, const std::type_info &ti, void &ptr, const std::string &docstring="", const void defval=0)
	Add a variable to the tuple.
virtual StatusCode	addDimensionedVariable (const std::string &name, const std::type_info &ti, void &ptr, const std::string &dim, const std::string &docstring="", const void defval=0)
	Add a variable to the tuple.
StatusCode	doConfigure (IAddVariable *tree, IIteration &it)
	Configure the tool.
StatusCode	doBook ()
	Declare tuple variables.
StatusCode	doFill (IIteration &it, size_t sizeHint)
	Fill objects from an `IIteration`.
void	maybeExtend (size_t &n, size_t &sz)
	Extend vectors if needed.
StatusCode	fillOnce (const void *obj, size_t objndx, size_t &n, size_t &sz, const std::vector< unsigned long > &codes_in, std::vector< unsigned long > &codes_out)
	Make one loop over block filler tools.
std::string ObjectMetadata::genSuffix	ATLAS_NOT_THREAD_SAFE (const std::string &name, size_t length)
	Generate a unique suffix for a metadata object name.
	DRAssociationTool (const std::string &type, const std::string &name, const IInterface *parent)
	Associate to particle closest in DR.
virtual const INavigable4Momentum *	get (const INavigable4Momentum &p) override
	Return the target object.
virtual const xAOD::IParticle *	get (const xAOD::IParticle &p) override
	Return the target object.
const	AmgSymMatrix (5) *PerigeeCovarianceAssociationTool
	Return the target object.
const	AmgSymMatrix (3) *VertexCovarianceAssociationTool
	Return the target object.

Variables
	scout = StatusCode(scout.getCode())
	m_next = m_associator->nextUntyped()
const void *	pout = m_associator->getUntyped (p)
std::string	m_targetLabel
	Fill one block.
std::string	m_prefix
	Property: The variable name prefix.
std::string	m_blockName
	Property: the name of this block.
ToolHandle< ICollectionGetterRegistryTool >	m_registry
	Property: The ICollectionGetterRegistryTool instance.
bool	m_allowMissing
	Property: Don't give an error if the target getter fails to find the input objects.
int *	m_index
	Index variable.
TypeConverter	m_converter
	Helper to convert from pointer returned by the associator to pointer into the index container.
IndexMap	m_map
	Map from objects to indices.
ToolHandle< ICollectionGetterTool >	m_getter
	Property: The collection getter tool.
std::string	m_objectName
	Property: the name of the D3PDObject that created this tool.
bool	m_saveMetadata
	Property: If true, the metadata about the variables is saved.
ID3PD *	m_tree
	Pointer to the ID3PD object used.
ObjectMetadata	m_metadata
	Metadata about the variables created by this tool.
ToolHandleArray< IBlockFillerTool >	m_blockFillers
	Property: The list of block filler tools.
std::string	m_nrowName
	Property: Name of the variable for the count of rows. Omitted if empty.
std::string	m_nobjName
	Property: Name of the variable for the count of objects. Omitted if empty.
std::string	m_objIndexName
	Property: Name of the variable for the object index. Omitted if empty.
int *	m_nrow
	Variable for the row count.
int *	m_nobj
	Variable for the object count.
int *	m_objIndex
	Variable for the object index.
Vars	m_vars
	All booked variables.
bool	again
float	m_drcut
	Property: DR cut.
float *	m_dr
	Variable: DR to associated object.
static const EventFlagNames	eventFlagNames []
static constexpr size_t	nEventFlagNames

Detailed Description

Block filler tool for noisy FEB information.

=========================== BEGIN OF COMMENTS ================================ Implementation of TileEventFillerTool, which is responsible for retrieving EventInfo and feeding the D3PD with event-by-event information.

Author: Laurent Duflot <duflot at lal.in2p3.fr>

Level of details can be set as follows:

0 NO INFORMATION
1 RUN AND EVENT NUMBERS, TIMESTAMP
2 NUMBER OF STACO/MUID MUONS
3 ELABORATE EVENT INFORMATION
4 TRIGGER DECISIONS
5 BASIC MISSING ENERGY
6 CALORIMETRIC MISSING ENERGY
7 ELABORATE MISSING ENERGY
8 INVARIANT MASS

Typedef Documentation

◆ ButFirstType_t

template<class T>

using D3PD::ButFirstType_t = typename ButFirstType<T>::type

Definition at line 129 of file PhysicsAnalysis/D3PDMaker/D3PDMakerUtils/D3PDMakerUtils/Types.h.

◆ Types

template<class... TYPES>

using D3PD::Types = std::tuple<WrapType<TYPES>...>

A simple tuple of multiple types.

This can be used as the type argument of BlockFillerTool and related templates in order to define a tool that can take one of a set of types as input. Eg,

D3PD::Types<Obj1, Obj2>

D3PD::Types

std::tuple< WrapType< TYPES >... > Types

A simple tuple of multiple types.

Definition PhysicsAnalysis/D3PDMaker/D3PDMakerUtils/D3PDMakerUtils/Types.h:61

Definition at line 61 of file PhysicsAnalysis/D3PDMaker/D3PDMakerUtils/D3PDMakerUtils/Types.h.

Function Documentation

◆ addDimensionedVariable()

virtual StatusCode D3PD::addDimensionedVariable	(	const std::string &	name,
		const std::type_info &	ti,
		void *&	ptr,
		const std::string &	dim,
		const std::string &	docstring = "",
		const void *	defval = 0 )

virtual

Add a variable to the tuple.

Parameters

name	The name of the variable.
type	The type of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling `fill()`.
dim	Dimension for the variable. (Presently unimplemented!)
docstring	Documentation string for this variable.
defval	Pointer to the default value to use for this variable. Null for no default (generally means to fill with zeros). Of the type given by `ti`. Only works for basic types.

◆ addVariable()

virtual StatusCode D3PD::addVariable	(	const std::string &	name,
		const std::type_info &	ti,
		void *&	ptr,
		const std::string &	docstring = "",
		const void *	defval = 0 )

virtual

Add a variable to the tuple.

Parameters

name	The name of the variable.
type	The type of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling `fill()`.
docstring	Documentation string for this variable.
defval	Pointer to the default value to use for this variable. Null for no default (generally means to fill with zeros). Of the type given by `ti`. Only works for basic types.

If called from the constructor, the only effect is to clear ptr.

◆ againok() [1/3]

return D3PD::againok ( scout )

◆ againok() [2/3]

StatusCode D3PD::againok ( StatusCode sc )

static

Fill one block.

Parameters

p	The input object.
again	Set if this is a subsequent call requested by an AGAIN return

This is called once per object. The type of the object at which p points is given by the ti argument to configure. The caller is responsible for arranging that all the pointers for booked variables are set appropriately upon entry.

If the return status is the special code AGAIN (defined above), then this filler tool wants to make multiple entries. The parent should set up to capture a new `row' and run through the list of block filler tools again, but for this tool call fillAgainUntyped instead of fillUntyped. This should be repeated as long as fillAgainUntyped returns AGAIN.

Once fillUntyped returns AGAIN, the parent should call fillUntyped with the same p argument and again set to true. This continues until fillUntyped returns something other than AGAIN.

Not all parents may support this. In that case, returning AGAIN will be treated as an error.

The return code may also be EMPTY if this tool did not fill in anything. If all tools return empty, the parent may omit the row. */ virtual StatusCode fillUntyped (const void* p, bool again = false) = 0;

/**

StatusCode check helper: change AGAIN or EMPTY to SUCCESS.

Parameters

sc	The StatusCode to check.

If sc is AGAIN or EMPTY, then return SUCCESS. Otherwise, return sc.

◆ againok() [3/3]

StatusCode D3PD::againok	(	StatusCode	sc,
		StatusCode &	scout )

static

StatusCode check helper: change AGAIN or EMPTY to SUCCESS.

Parameters

sc	The StatusCode to check.
scout[out]	Accumulated status code.

If sc is AGAIN or EMPTY, then return SUCCESS. Otherwise, return sc.

If sc is AGAIN, then scout will be set to AGAIN. Otherwise, if sc is not EMPTY, then scout will be set to sc.

◆ AmgSymMatrix() [1/2]

const D3PD::AmgSymMatrix ( 3 )

Return the target object.

Parameters

p	The source object for the association.

Return the target of the association, or 0.

Definition at line 39 of file VertexCovarianceAssociationTool.cxx.

{
  return &(p.recVertex().covariancePosition());
}

◆ AmgSymMatrix() [2/2]

const D3PD::AmgSymMatrix ( 5 )

Return the target object.

Parameters

p	The source object for the association.

Return the target of the association, or 0.

Definition at line 43 of file PerigeeCovarianceAssociationTool.cxx.

{
  // cast to MeasuredPerigee
  //const Trk::MeasuredPerigee *measPerigee = dynamic_cast<const Trk::MeasuredPerigee *>(&p);
  const AmgSymMatrix(5) * cov  = p.covariance();
  if (cov) {
    // return pointer to Covariance Matrix
    return cov;
  }else{
    REPORT_MESSAGE (MSG::WARNING) << "Could not cast Trk::Perigee to Trk::MeasuredPerigee";
  }
 
  return 0;
}

◆ ATLAS_NOT_THREAD_SAFE() [1/2]

std::string ObjectMetadata::metadataName D3PD::ATLAS_NOT_THREAD_SAFE ( void ) const

Standard Gaudi initialize method.

When saving the "serialized" version of the object as metadata into a D3PD file, this function should be used to construct the name of the metadata object.

The name receives a "random component" to make sure that when a single job uses the same D3PDObject multiple times, possibly with different detail levels, we would save the variable definitions for both into the output file.

Returns: A unique name, containing the D3PDObject's name

Definition at line 69 of file DummyInitAlg.cxx.

{
  CHECK( AthAlgorithm::initialize() );
 
  // THistSvc has a bug whereby if it opens output files,
  // then it leaves the root directory pointing at the last output
  // file when initialize returns.  This means that other root
  // objects that are meant to be transient can end up in this file.
  // Worse, we can get a double-delete, as these transient objects
  // will then be deleted when the file is closed.
  //
  // We do this here in the hope that we're the first to call THistSvc.
  // Maybe we should also bash the current directory back to TROOT?
  //
  // This can be removed once this is fixed in THistSvc.
  // https://savannah.cern.ch/bugs/index.php?60162
  {
    DirectoryRestore save;
    CHECK( m_histSvc.retrieve() );
  }
 
  CHECK( detStore().retrieve() );
  return StatusCode::SUCCESS;
}

◆ ATLAS_NOT_THREAD_SAFE() [2/2]

std::string ObjectMetadata::genSuffix D3PD::ATLAS_NOT_THREAD_SAFE	(	const std::string &	name,
		size_t	length )

Generate a unique suffix for a metadata object name.

Parameters

name	The metadata object name.
length	The length of the suffix to add.

We used to do this by generating a random string. However, this is very bad for regression testing, as adding or removing one variable can then change the names of all subsequent variables. Instead, we generate the suffix based on a count of the number of times we've seen a particular name.

Definition at line 406 of file ObjectMetadata.cxx.

   {
 
     // Count of the number of times a given name was used,
     // in order to assign them a unique suffix.
     static std::unordered_map<std::string, size_t> namecount;
 
     const size_t count = ++namecount[name];
     std::ostringstream os;
     os << std::setw(length) << std::setprecision(length) << std::setfill('0')
        << count;
     return os.str();
   }

◆ book()

StatusCode D3PD::book ( )

overridevirtual

Declare tuple variables.

Create any needed tuple variables.

This is called at the start of the first event.

◆ CHECK() [1/2]

D3PD::CHECK ( doFill *, 0m_associator )

Fill one block.

Parameters

p	The input object.
again	Set if this is a subsequent call requested by an AGAIN return

This is called once per object. The type of the object at which p points is given by the ti argument to configureD3PD. The caller is responsible for arranging that all the pointers for booked variables are set appropriately upon entry.

If the return status is the special code AGAIN (defined above), then this filler tool wants to make multiple entries. The parent should set up to capture a new `row' and run through the list of block filler tools again, but for this tool call fillAgainUntyped instead of fillUntyped. This should be repeated as long as fillAgainUntyped returns AGAIN.

Once fillUntyped returns AGAIN, the parent should call fillUntyped with the same p argument and again set to true. This continues until fillUntyped returns something other than AGAIN.

Not all parents may support this. In that case, returning AGAIN will be treated as an error. */ StatusCode ContainedVectorMultiAssociationFillerTool::fillUntyped (const void* p, bool /*again = false

◆ CHECK() [2/2]

D3PD::CHECK ( m_associator-> resetUntypedp )

Fill one block.

Parameters

p	The input object.
again	Set if this is a subsequent call requested by an AGAIN return

This is called once per object. The type of the object at which p points is given by the ti argument to configureD3PD. The caller is responsible for arranging that all the pointers for booked variables are set appropriately upon entry.

If the return status is the special code AGAIN (defined above), then this filler tool wants to make multiple entries. The parent should set up to capture a new `row' and run through the list of block filler tools again, but for this tool call fillAgainUntyped instead of fillUntyped. This should be repeated as long as fillAgainUntyped returns AGAIN.

Once fillUntyped returns AGAIN, the parent should call fillUntyped with the same p argument and again set to true. This continues until fillUntyped returns something other than AGAIN.

Not all parents may support this. In that case, returning AGAIN will be treated as an error. */ StatusCode IndexMultiAssociationFillerTool::fillUntyped (const void* p, bool /*again = false

◆ clidToTypeinfo()

StatusCode D3PD::clidToTypeinfo	(	CLID	clid,
		const std::string &	name,
		std::type_info const *&	ti,
		const std::string &	context )

Convert from a CLID to a type_info; we also already know the name.

Parameters

clid	The CLID to convert.
name	The name of the class to convert.
ti[out]	The resulting type_info.
context	Context name, for error reporting.

Definition at line 98 of file TypeNameConversions.cxx.

{
  ti = 0;
  const SG::BaseInfoBase* bib = SG::BaseInfoBase::find (clid);
  if (bib) {
    ti = &bib->typeinfo();
    return StatusCode::SUCCESS;
  }
 
  // Hmm.. no BaseInfo.  Maybe Root knows it.
  const TClass* cls =  TClass::GetClass (name.c_str());
  if (cls){
    ti = cls->GetTypeInfo();
    if (ti)
      return StatusCode::SUCCESS;
  }
 
  REPORT_MESSAGE_WITH_CONTEXT (MSG::ERROR, context)
    << "Can't find typeinfo for CLID "
    << clid << " (type " << name << ").";
  return StatusCode::FAILURE;
}

◆ configureD3PD() [1/2]

StatusCode D3PD::configureD3PD ( IAddVariable * tree )

virtual

Configure the tool.

Abstract interface for tool to fill an object in the D3PD.

Parameters

tree	The parent D3PD tree.

This is called during initialization.

Each tree consists of a set of objects. Each of these will generally correspond to one C++ object, or set of objects in a container. Each object is filled by a tool of type IObjFillerTool. (These tools are intended to be generic; the object-specific code is in block filling). For the case of objects in a container, all the filled tuple leaves should start with a common prefix (e.g., `el_'), and a count leaf will be automatically added (`el_n'). For single objects not in a container, a prefix is optional; but if present should be common to all the leaves of the object.

Inputs to object filler tools are provided by `getter' tools. */ class IObjFillerTool : virtual public IAlgTool { public: / Gaudi interface definition. DeclareInterfaceID(IObjFillerTool, 1, 0);

/**

Configure the tool.

Parameters

tree	The parent D3PD tree.

This is called during initialization.

◆ configureD3PD() [2/2]

StatusCode D3PD::configureD3PD	(	IAddVariable *	tree,
		const std::type_info &	ti )

overridevirtual

Configure during initialization: type-check.

Abstract interface for tool to fill a block in the D3PD.

Parameters

tree	Our parent for tuple making.
ti	Gives the type of the object being passed to `fillUntyped`.

configureD3PD should check that the type of the object coming as input is compatible with what it expects, and raise an error otherwise.

Each object consists of a set of blocks. A block is a small set of related tuple variables for some object. Blocks represent the intended granularity for enabling or disabling variables (though it should be possible to control individual variables through the remapping mechanism). Blocks are filled by tools of type IBlockFillerTool. Blocks (and the associated tools) will generally be specific for a particular object type (i.e., fill the egamma PID variables) A few, however, will be more generic: for example, there should be one block tool for filling 4-vector information that's used by all object types (that implement 4-vectors).

Each block is associated with a specific `level of detail' in job configuration. This allows enabling a preselected set of blocks.

Each block has a default variable name for each leaf filled. This is concatenated with the object prefix (if any) to produce the full name for the leaf. It will be possible to configure the filler tools to change the names of the tuple leaves (this should be implemented with generic code in a base class). The same mechanism may be used to disable specific leaves entirely by remapping to a null name. (Remapping is not yet implemented.)

User-written code will generally not implement this interface directly, but will instead use the type-safe wrappers provided by BlockFillerTool. */ class IBlockFillerTool : virtual public IAlgTool { public: / Gaudi interface definition. DeclareInterfaceID(IBlockFillerTool, 1, 0);

/ Special status code to indicate that we want fillAgainUntyped / to be called; see below. enum { AGAIN = 1001, EMPTY = 1002 };

/**

Configure during initialization: type-check.

Parameters

tree	Our parent for tuple making.
ti	Gives the type of the object being passed to `fillUntyped`.

configureD3PD should check that the type of the object coming as input is compatible with what it expects, and raise an error otherwise.

◆ ContainedVectorMultiAssociationFillerTool()

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

Represent a multiple association by containment inside vectors.

Standard Gaudi tool constructor.

This is a block filler tool which represents a multiple association by containment; the variables in the contained blocks will appear inside of vectors. (This implies that if this block itself is used with, say, VectorFillerTool, then we'll end up with nested vectors.)

It takes as a property an IMultiAssociationTool. For each input object, it asks the association tool which objects are associated with it; the result is a collection of 0 or more objects. This tool also has a list of block filler tools; these tools are called for the result of the association.

Properties:

Associator - The IMultiAssociationTool.

Properties inherited from VectorFillerToolBase:

BlockFillers - List of IBlockFillerTool instances. Prefix - Prefix to add to variable names for this block. NrowName - Name of the variable for the count of rows. Omitted if empty. Default: `n'. NobjName - Name of the variable for the count of objects. (May be less than the number of rows if AGAIN is used.) Omitted if empty (default). ObjIndexName - Name of the variable for the object index. Omitted if empty (default). */ class ContainedVectorMultiAssociationFillerTool : public extends<VectorFillerToolBase, IBlockFillerTool> { public: /**

Standard Gaudi tool constructor.

Parameters

type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.
type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.

Definition at line 27 of file ContainedVectorMultiAssociationFillerTool.cxx.

     : base_class (type, name, parent),
       m_associator (this)
{
  declareProperty ("Associator",   m_associator,
                   "The IMultiAssociationTool instance.");
}

◆ doBook()

StatusCode D3PD::VectorFillerToolBase::doBook ( )

protected

Declare tuple variables.

This is called at the start of the first event.

Definition at line 112 of file VectorFillerToolBase.cxx.

{
  // Create the count/index variables.
   if (!m_nrowName.empty()) {
      CHECK( m_metadata.addVariable (m_prefix + m_nrowName, m_nrow,
                                     "Number of ntuple rows.") );
      CHECK( m_tree->addVariable (m_prefix + m_nrowName, m_nrow,
                                  "Number of ntuple rows.") );
   }
   if (!m_nobjName.empty()) {
      CHECK( m_metadata.addVariable (m_prefix + m_nobjName, m_nobj,
                                     "Number of objects.") );
      CHECK( m_tree->addVariable (m_prefix + m_nobjName, m_nobj,
                                  "Number of objects.") );
   }
   if (!m_objIndexName.empty())
      CHECK( IAddVariable::addVariable (m_objIndexName, m_objIndex,
                                        "Index of this object.") );
 
  // Book child variables.
  for (size_t i = 0; i < m_blockFillers.size(); i++)
    CHECK( m_blockFillers[i]->book() );
 
  return StatusCode::SUCCESS;
}

◆ doConfigure()

StatusCode D3PD::VectorFillerToolBase::doConfigure	(	IAddVariable *	tree,
		IIteration &	it )

protected

Configure the tool.

Parameters

tree	The parent D3PD tree.
it	The iteration object we'll use. (Used to get the elt type.)

This is called during initialization.

Definition at line 147 of file VectorFillerToolBase.cxx.

{
  m_tree = tree;
 
  // Get the type of object we'll get from the iteration.
  const std::type_info& ti = it.elementTypeinfo();
 
  // Configure all child tools.
  for (size_t i = 0; i < m_blockFillers.size(); i++)
    CHECK( m_blockFillers[i]->configureD3PD (this, ti) );
 
  return StatusCode::SUCCESS;
}

◆ doFill()

StatusCode D3PD::VectorFillerToolBase::doFill	(	IIteration &	it,
		size_t	sizeHint )

protected

Fill objects from an IIteration.

Parameters

it	Iteration object. Must have already been reset.
sizeHint	Hint for the expected size of the iteration.

This will loop over the objects in the iteration; for each object, it will loop over the contained block filler tools.

Parameters

it	Iteration object. Must have already been reset.

This will loop over the objects in the iteration; for each object, it will loop over the contained block filler tools.

Definition at line 244 of file VectorFillerToolBase.cxx.

{
  // Set variable vectors to the expected size.
  m_vars.resize_all (sizeHint);
  size_t n = 0;
  size_t nobj = 0;
  size_t sz = sizeHint;
 
  std::vector<unsigned long> codes_in;
  std::vector<unsigned long> codes_out;
 
  // Loop over objects.
  // Note: @c nextUntyped may try to fill variables.  Make sure there's space.
  maybeExtend (n, sz);
  while (const void* obj = it.nextUntyped() ) {
    // AGAIN processing.
    codes_in.clear();
    codes_in.resize (m_blockFillers.size(), StatusCode(StatusCode::SUCCESS).getCode());
    CHECK( fillOnce (obj, nobj, n, sz, codes_in, codes_out) );
    codes_in = codes_out;
    while (std::find (codes_out.begin(), codes_out.end(),
                      (unsigned long)IBlockFillerTool::AGAIN)
           != codes_out.end())
    {
      CHECK( fillOnce (obj, nobj, n, sz, codes_in, codes_out) );
    }
 
    ++nobj;
 
    it.releaseElementUntyped (obj);
    maybeExtend (n, sz);
  }
 
  // Set vectors to the proper final size.
  if (sz != n)
    m_vars.resize_all (n);
 
  // Save the counts.
  if (m_nrow)
    *m_nrow = n;
  if (m_nobj)
    *m_nobj = nobj;
 
  return StatusCode::SUCCESS;
}

◆ DRAssociationTool()

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

Associate to particle closest in DR.

Standard Gaudi tool constructor.

This is a single association tool. Given an INavigable4Momentum object and a container of such objects, return the object in the container closest in DR to the input object. Optionally, a DR cut may be set; the association fails if there are no objects within that cut.

Parameters: Getter - ICollectionGetterTool instance defining the target collection. DRCut - DR cut for the association. (default: 999)

This tool will create a tuple variable `dr' giving the distance in DR to the associated object. */ class DRAssociationTool : public SingleAssociationTool<Types<INavigable4Momentum, xAOD::IParticle> > { public: typedef SingleAssociationTool<Types<INavigable4Momentum, xAOD::IParticle> > Base;

/**

Standard Gaudi tool constructor.

Parameters

type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.
type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.

Definition at line 33 of file DRAssociationTool.cxx.

  : Base (type, name, parent),
    m_getter (this)
{
  declareProperty ("Getter", m_getter,
                   "ICollectionGetterTool instance defining "
                   "the target collection");
  declareProperty ("DRCut", m_drcut = 999,
                   "DR cut for the association");
 
  DRAssociationTool::book().ignore();  // Avoid coverity warnings.
}

◆ fill()

return D3PD::fill ( )

virtual

Fill one object.

This is called once per event. It should:

Fetch the input.
If it's a container, loop over the contents.
Loop over the contained block filler tools.

◆ fillOnce()

StatusCode D3PD::VectorFillerToolBase::fillOnce	(	const void *	obj,
		size_t	objndx,
		size_t &	n,
		size_t &	sz,
		const std::vector< unsigned long > &	codes_in,
		std::vector< unsigned long > &	codes_out )

private

Make one loop over block filler tools.

Parameters

obj	Object being processed.
objndx	The index of the object we're currently processing.
n	Number of entries currently made in the vectors.
sz	Current size of the vectors.
codes_in	Vector of status returns for each tool from the first `fill` call.
codes_out[out]	Vector of status returns for each tool from this `fill` call.

This function may be called more than once for an object if AGAIN was requested.

We loop over all block filler tools. For each, we call fillUntyped with the again parameter set depending on whether codes_in for this tool is AGAIN. We collect the return codes from each tool in codes_out.

Definition at line 196 of file VectorFillerToolBase.cxx.

{
  codes_out.resize (m_blockFillers.size());
 
  // Extend vectors if needed.
  maybeExtend (n, sz);
 
  // Loop over block fillers.
  bool all_empty = true;
  for (size_t j = 0; j < m_blockFillers.size(); j++) {
    StatusCode scode =
      m_blockFillers[j]->fillUntyped(obj,
                                     codes_in[j] == IBlockFillerTool::AGAIN);
    codes_out[j] = scode.getCode();
    if (codes_out[j] != IBlockFillerTool::EMPTY)
      all_empty = false;
    CHECK( IBlockFillerTool::againok (scode) );
  }
 
  // If all tools returned empty, then ignore this row.
  // But don't ignore it if there are no block fillers at all
  // (it may be that an associator tool will be filling variables).
  if (!all_empty || m_blockFillers.empty()) {
    if (m_objIndex)
      *m_objIndex = objndx;
 
    // Count rows and update variable pointers.
    ++n;
    m_vars.next_all();
  }
 
  return StatusCode::SUCCESS;
}

◆ finalize()

virtual StatusCode D3PD::finalize ( )

virtual

Standard Gaudi finalize method.

◆ for()

D3PD::for ( )

Fill one block.

Parameters

p	The input object.
again	Set if this is a subsequent call requested by an AGAIN return

This is called once per object. The type of the object at which p points is given by the ti argument to configureD3PD. The caller is responsible for arranging that all the pointers for booked variables are set appropriately upon entry.

If the return status is the special code AGAIN (defined above), then this filler tool wants to make multiple entries. The parent should set up to capture a new `row' and run through the list of block filler tools again, but for this tool call fillAgainUntyped instead of fillUntyped. This should be repeated as long as fillAgainUntyped returns AGAIN.

Once fillUntyped returns AGAIN, the parent should call fillUntyped with the same p argument and again set to true. This continues until fillUntyped returns something other than AGAIN.

Not all parents may support this. In that case, returning AGAIN will be treated as an error.

The return code may also be EMPTY if this tool did not fill in anything. If all tools return empty, the parent may omit the row. */ StatusCode ContainedMultiAssociationFillerTool::fillUntyped (const void* p, bool again /*= false

Definition at line 164 of file ContainedMultiAssociationFillerTool.cxx.

                                                   {
    StatusCode sc = m_blockFillers[i]->fillUntyped (m_next);
    CHECK( IBlockFillerTool::againok (sc) );
    if (!sc.isSuccess()) {
      REPORT_MESSAGE (MSG::WARNING)
        << "Got AGAIN/EMPTY: "
        << "Nested ContainedMultiAssociationFillerTool not supported.";
    }
  }

◆ get() [1/2]

virtual const INavigable4Momentum * D3PD::get ( const INavigable4Momentum & p )

overridevirtual

Return the target object.

Parameters

p	The source object for the association.

Return the target of the association, or 0.

◆ get() [2/2]

virtual const xAOD::IParticle * D3PD::get ( const xAOD::IParticle & p )

overridevirtual

Return the target object.

Parameters

p	The source object for the association.

Return the target of the association, or 0.

◆ handle()

virtual void D3PD::handle ( const Incident & inc )

virtual

Handle end of run incidents to save the metadata at that point.

◆ if() [1/3]

D3PD::if ( m_index )

Fill one block.

Parameters

p	The input object.
again	Set if this is a subsequent call requested by an AGAIN return

This is called once per object. The type of the object at which p points is given by the ti argument to configureD3PD. The caller is responsible for arranging that all the pointers for booked variables are set appropriately upon entry.

If the return status is the special code AGAIN (defined above), then this filler tool wants to make multiple entries. The parent should set up to capture a new `row' and run through the list of block filler tools again, but for this tool call fillAgainUntyped instead of fillUntyped. This should be repeated as long as fillAgainUntyped returns AGAIN.

Once fillUntyped returns AGAIN, the parent should call fillUntyped with the same p argument and again set to true. This continues until fillUntyped returns something other than AGAIN.

Not all parents may support this. In that case, returning AGAIN will be treated as an error. */ StatusCode IndexAssociationFillerTool::fillUntyped (const void* p, bool /*again = false

◆ if() [2/3]

D3PD::if ( m_next||! again )

◆ if() [3/3]

D3PD::if ( pout )

Definition at line 141 of file ContainedAssociationFillerTool.cxx.

            {
    if (!m_matchedName.empty())
      *m_matched = true;
    for (size_t i = 0; i < m_blockFillers.size(); i++) {
      // Set checked flag on scout.
      // Otherwise, if we get an exception in the child, all we'll see
      // is an unchecked status code error with no mention of the
      // actual exception...
      scout.ignore();
      CHECK( againok (m_blockFillers[i]->fillUntyped (pout, again), scout) );
    }
  }

◆ IndexAssociationFillerTool()

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

Represent a single association by index.

Standard Gaudi tool constructor.

This is a block filler tool which represents a single association by index.

It takes as a property an ISingleAssociationTool. For each input object, it asks the association tool which object is associated with it. It also takes as a property a collection getter label. This defines an `index' collection. The tool searches this collection for the target of the association and finds the index of that object within that collection. That index is then booked as a variable.

The index is set to -1 if the association fails or if the object isn't found in the index container.

Properties: Associator - The ISingleAssociationTool instance. Target - Label of the collection getter defining the collection within which to index. Prefix - Variable name prefix for the contained blocks. CollectionGetterRegistry - The ICollectionGetterRegistryTool instance. */ class IndexAssociationFillerTool : public extends<AthAlgTool, IBlockFillerTool>, public AddVariable { public: /**

Standard Gaudi tool constructor.

Parameters

type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.
type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.

Definition at line 28 of file IndexAssociationFillerTool.cxx.

     : base_class (type, name, parent),
       AddVariable (m_prefix, m_blockName),
       m_associator (this),
       m_index (0),
       m_map (this, m_targetLabel, m_registry, m_allowMissing)
{
  declareProperty ("Associator",    m_associator,
                   "The ISingleAssociationTool instance.");
  declareProperty ("Target",        m_targetLabel,
                   "Label of the collection getter defining the collection "
                   "within which to index.");
  declareProperty ("Prefix",        m_prefix,
                   "Variable name prefix for the index variable.");
  declareProperty ("BlockName", m_blockName = this->name(),
                   "The name of this block.");
  declareProperty ("CollectionGetterRegistry", m_registry,
                   "The ICollectionGetterRegistryTool instance.");
  declareProperty ("AllowMissing", m_allowMissing = false,
                   "If true, then it is not considered an error for the "
                   "target getter to fail to find the input objects.");
}

◆ IndexMultiAssociationFillerTool()

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

Represent a multiple association by index.

Standard Gaudi tool constructor.

This is a block filler tool which represents a multiple association by a collection of indices.

It takes as a property an IMultiAssociationTool. For each input object, it asks the association tool which objects are associated with it; the result is a collection of 0 or more objects. It also takes as a property a collection getter label. This defines an `index' collection. The tool searches this collection for each target of the association and finds the index of that object within that collection. The result is booked as a vector of ints.

Objects that aren't found in the index collection are omitted from the index vector.

Properties: Associator - The IMultiAssociationTool instance. Target - Label of the collection getter defining the collection within which to index. Prefix - Variable name prefix for the contained blocks. CollectionGetterRegistry - The ICollectionGetterRegistryTool instance. */ class IndexMultiAssociationFillerTool : public extends<AthAlgTool, IBlockFillerTool>, public AddVariable { public: /**

Standard Gaudi tool constructor.

Parameters

type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.
type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.

Definition at line 28 of file IndexMultiAssociationFillerTool.cxx.

     : base_class (type, name, parent),
       AddVariable (m_prefix, m_blockName),
       m_associator (this),
       m_index (0),
       m_map (this, m_targetLabel, m_registry, m_allowMissing)
{
  declareProperty ("Associator",    m_associator,
                   "The ISingleAssociationTool instance.");
  declareProperty ("Target",        m_targetLabel,
                   "Label of the collection getter defining the collection "
                   "within which to index.");
  declareProperty ("Prefix",        m_prefix,
                   "Variable name prefix for the index variable.");
  declareProperty ("BlockName", m_blockName = this->name(),
                   "The name of this block.");
  declareProperty ("CollectionGetterRegistry", m_registry,
                   "The ICollectionGetterRegistryTool instance.");
  declareProperty ("AllowMissing", m_allowMissing = false,
                   "If true, then it is not considered an error for the "
                   "target getter to fail to find the input objects.");
}

◆ initialize()

StatusCode D3PD::initialize ( )

overridevirtual

Standard Gaudi initialize method.

Standard Gaudi initialize method.

◆ isContainerFiller()

bool D3PD::isContainerFiller ( ) const

virtual

Find out if the filler handles containers or single objects.

This is used by the D3PDReader code generator to know how to create the generated source files exactly.

◆ maybeExtend()

void D3PD::VectorFillerToolBase::maybeExtend	(	size_t &	n,
		size_t &	sz )

private

Extend vectors if needed.

Parameters

n	Number of entries currently made in the vectors.
sz	Current size of the vectors.

Definition at line 167 of file VectorFillerToolBase.cxx.

{
  if (n >= sz) {
    sz = std::max(static_cast<size_t>(16), 2*sz);
    m_vars.resize_all (sz, n);
  }
}

◆ multiTypeInfo() [1/3]

template<class T>

const std::type_info & D3PD::multiTypeInfo	(	T *	,
		size_t	)

Definition at line 108 of file PhysicsAnalysis/D3PDMaker/D3PDMakerUtils/D3PDMakerUtils/Types.h.

{
  return typeid (T);
}

◆ multiTypeInfo() [2/3]

template<class T0>

const std::type_info & D3PD::multiTypeInfo	(	Types< T0 > *	,
		size_t	which )

Return one type_info from a tuple.

If T is Types<T0, ...>, then multiTypeInfo (T*, which) will return typeid(Twhich). Otherwise, it will return typeid(T).

Definition at line 92 of file PhysicsAnalysis/D3PDMaker/D3PDMakerUtils/D3PDMakerUtils/Types.h.

{
  if (which == 0) return typeid (T0);
  std::abort();
}

◆ multiTypeInfo() [3/3]

template<class T0, class... TYPES>

const std::type_info & D3PD::multiTypeInfo	(	Types< T0, TYPES... > *	,
		size_t	which )

Definition at line 100 of file PhysicsAnalysis/D3PDMaker/D3PDMakerUtils/D3PDMakerUtils/Types.h.

{
  if (which == 0) return typeid (T0);
  return multiTypeInfo (static_cast<Types<TYPES...>*>(nullptr), which-1);
}

◆ nameToCLID()

StatusCode D3PD::nameToCLID	(	const std::string &	name,
		CLID &	clid,
		const std::string &	context,
		const ServiceHandle< IClassIDSvc > &	clidsvc = ServiceHandle<IClassIDSvc>("ClassIDSvc", "TypeNameConversions") )

Convert from a class name to a CLID.

Parameters

name	The class name to convert.
ti[out]	The resulting type_info.
context	Context name, for error reporting.
clidsvc	Handle to the CLID service.
name	The class name to convert.
clid[out]	The resulting CLID.
context	Context name, for error reporting.
clidsvc	Handle to the CLID service.

Definition at line 71 of file TypeNameConversions.cxx.

{
  clid = CLID_NULL;
  CHECK_WITH_CONTEXT( clidsvc.retrieve(), context );
 
  if (clidsvc->getIDOfTypeName (name, clid).isSuccess())
    return StatusCode::SUCCESS;
  if (clidsvc->getIDOfTypeInfoName (name, clid).isSuccess())
    return StatusCode::SUCCESS;
 
  REPORT_MESSAGE_WITH_CONTEXT (MSG::ERROR, context)
    << "Can't find CLID for type name " << name;
  return StatusCode::FAILURE;
}

◆ nameToTypeinfo()

StatusCode D3PD::nameToTypeinfo	(	const std::string &	name,
		std::type_info const *&	ti,
		const std::string &	context,
		const ServiceHandle< IClassIDSvc > &	clidsvc = ServiceHandle<IClassIDSvc>("ClassIDSvc", "TypeNameConversions") )

Convert from a class name to a type_info.

Parameters

name	The class name to convert.
ti[out]	The resulting type_info..
context	Context name, for error reporting.
clidsvc	Handle to the CLID service.

Definition at line 32 of file TypeNameConversions.cxx.

{
  ti = 0;
 
  // See if root knows the type.
  const TClass* cls = TClass::GetClass (name.c_str());
  if (cls) {
    ti = cls->GetTypeInfo();
    if (ti) return StatusCode::SUCCESS;
  }
 
  // Try to look it up using BaseInfo.  First need to convert to a CLID.
  CLID clid;
  if (nameToCLID (name, clid, context, clidsvc).isSuccess()) {
    const SG::BaseInfoBase* bib = SG::BaseInfoBase::find (clid);
    if (bib) {
      ti = &bib->typeinfo();
      return StatusCode::SUCCESS;
    }
  }
 
  REPORT_MESSAGE_WITH_CONTEXT (MSG::ERROR, context)
    << "Can't convert type name " << name << " to type_info.";
 
  return StatusCode::FAILURE;
}

◆ operator+()

ObjectMetadata D3PD::operator+	(	const ObjectMetadata &	obj1,
		const ObjectMetadata &	obj2 )

Operator for creating the sum of two metadata objects.

Definition at line 582 of file ObjectMetadata.cxx.

                                                           {
 
      ObjectMetadata result( obj1 );
      return result += obj2;
   }

◆ releaseElementUntyped()

m_associator D3PD::releaseElementUntyped ( m_next )

◆ releaseObjectUntyped()

m_associator D3PD::releaseObjectUntyped ( pout )

◆ scout()

StatusCode D3PD::scout ( EMPTY )

Fill one block.

Parameters

p	The input object.
again	Set if this is a subsequent call requested by an AGAIN return

This is called once per object. The type of the object at which p points is given by the ti argument to configureD3PD. The caller is responsible for arranging that all the pointers for booked variables are set appropriately upon entry.

If the return status is the special code AGAIN (defined above), then this filler tool wants to make multiple entries. The parent should set up to capture a new `row' and run through the list of block filler tools again, but for this tool call fillAgainUntyped instead of fillUntyped. This should be repeated as long as fillAgainUntyped returns AGAIN.

Once fillUntyped returns AGAIN, the parent should call fillUntyped with the same p argument and again set to true. This continues until fillUntyped returns something other than AGAIN.

Not all parents may support this. In that case, returning AGAIN will be treated as an error.

The return code may also be EMPTY if this tool did not fill in anything. If all tools return empty, the parent may omit the row. */ StatusCode ContainedAssociationFillerTool::fillUntyped (const void* p, bool again /*= false

◆ typeinfoToName()

std::string D3PD::typeinfoToName ( const std::type_info & ti )

Convert from a type_info to a name.

Parameters

ti	The type_info to convert.

Definition at line 129 of file TypeNameConversions.cxx.

{
  // Handle fundamental types.
  if (ti == typeid(float))
    return "float";
  else if (ti == typeid(double))
    return "double";
  else if (ti == typeid(int))
    return "int";
  else if (ti == typeid(bool))
    return "bool";
  else if (ti == typeid(char))
    return "char";
  else if (ti == typeid(signed char))
    return "signed char";
  else if (ti == typeid(unsigned char))
    return "unsigned char";
  else if (ti == typeid(short))
    return "short";
  else if (ti == typeid(unsigned short))
    return "unsigned short";
  else if (ti == typeid(unsigned int))
    return "unsigned int";
  else if (ti == typeid(long))
    return "long";
  else if (ti == typeid(unsigned long))
    return "unsigned long";
  else if (ti == typeid(long long))
    return "long long";
  else if (ti == typeid(unsigned long long))
    return "unsigned long long";
  else if (ti == typeid(long double))
    return "long double";
  else if (ti == typeid(wchar_t))
    return "wchar_t";
 
  // Otherwise try to look it up with root.
  std::string eltname;
  TClass* eltcls = TClass::GetClass (ti);
  if (eltcls) {
    eltname = eltcls->GetName();
  }
  else {
    std::string eltname = System::typeinfoName (ti);
    eltcls = TClass::GetClass (eltname.c_str());
    if (eltcls)
      eltname = eltcls->GetName();
  }
  return eltname;
}

◆ VectorFillerTool()

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

Object filler tool for a collection of objects, saved as vectors.

Standard Gaudi tool constructor.

This is an object filler tool for a collection of objects. The object variables are saved as vectors. I.e., if a block books a variable of type int', the variable we actually create is of type vector<int>'. An additional variable giving the object count is added automatically (can be controlled via the NrowName property).

This tool has the following properties:

Getter - ICollectionGetterTool instance. AllowMissing - If true, then it is not considered an error for the requested input object to be missing.

and the following inherited from VectorFillerToolBase:

BlockFillers - List of IBlockFillerTool instances. Prefix - Prefix to add to variable names for this block. NrowName - Name of the variable for the count of rows. Omitted if empty. Default: `n'. NobjName - Name of the variable for the count of objects. (May be less than the number of rows if AGAIN is used.) Omitted if empty (default). ObjIndexName - Name of the variable for the object index. Omitted if empty (default).

For each event, we call the getter to retrieve the collection. We then loop over the objects in the collection. For each object, we set the variable pointers to point to the proper locations within the vectors. Then we loop over all block filler tools, passing the object to each. */ class VectorFillerTool : public extends<VectorFillerToolBase, IObjFillerTool, IIncidentListener> { public: /**

Standard Gaudi tool constructor.

Parameters

type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.
type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.

Definition at line 30 of file VectorFillerTool.cxx.

  : base_class (type, name, parent),
    m_getter (this),
    m_tree (0)
{
  declareProperty ("Getter",       m_getter,
                   "The ICollectionGetterTool instance.");
  declareProperty ("ObjectName", m_objectName = "",
                   "Name of the D3PDObject that created this filler.");
  declareProperty ("AllowMissing", m_allowMissing = false,
                   "If true, then it is not considered an error for the "
                   "requested input object to be missing.");
  declareProperty ("SaveMetadata", m_saveMetadata = false,
                   "Set to true to get metadata into the output D3PD "
                   "about the variables created by this tool");
}

◆ VectorFillerToolBase()

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

Common code for wrapping filled variables up into a vector.

Standard Gaudi tool constructor.

In several places we want to be able to run a set of block filler tools over a set of objects and wrap the results up in vectors. This is used at least in VectorFillerTool and ContainedVectorMultiAssociationFillerTool. This class factors out the common behavior involved in wrapping results up in vectors.

The actual iteration over a set of objects is expressed by the interface IIteration. The way this class is used is as follows:

Call doConfigure from your configureD3PD method. Pass in the IIteration instance.
Call doBook from your book method.
To do a fill, first do whatever's needed to prepare the IIteration instance to iterate over the desired object set. Then pass it to doFill.

doFill will iterate over the objects in the IIteration; for each of these, it will loop over the block filler tools.

The results will be collected inside of vectors.

This tool has the following properties:

BlockFillers - List of IBlockFillerTool instances. Prefix - Prefix to add to variable names for this block. NrowName - Name of the variable for the count of rows. Omitted if empty. Default: `n'. NobjName - Name of the variable for the count of objects. (May be less than the number of rows if AGAIN is used.) Omitted if empty (default). ObjIndexName - Name of the variable for the object index. Omitted if empty (default). */ class VectorFillerToolBase : public AthAlgTool, public IAddVariable { public: /**

Standard Gaudi tool constructor.

Parameters

type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.
type	The name of the tool type.
name	The tool name.
parent	The tool's Gaudi parent.

Definition at line 56 of file VectorFillerToolBase.cxx.

  : AthAlgTool (type, name, parent),
    m_metadata (),
    m_prefix (),
    m_blockFillers (this),
    m_tree (0),
    m_nrow (0),
    m_nobj (0),
    m_objIndex (0)
{
  declareProperty ("BlockFillers", m_blockFillers,
                   "List of contained block filler tools.");
  declareProperty ("Prefix",       m_prefix = "",
                   "Variable name prefix for the contained blocks.");
  declareProperty ("NrowName",     m_nrowName = "n",
                   "Name of the variable for the count of rows. "
                   "Omitted if empty.");
  declareProperty ("NobjName",     m_nobjName = "",
                   "Name of the variable for the count of objects. "
                   "Omitted if empty.");
  declareProperty ("ObjIndexName", m_objIndexName = "",
                   "Name of the variable for the object index. "
                   "Omitted if empty.");
}

◆ while()

D3PD::while ( const void * pout = m_associator->nextUntyped () )

Definition at line 158 of file IndexMultiAssociationFillerTool.cxx.

  {
    if (m_index) {
      // Convert to the proper pointer type to search in the container.
      const void* pnew = m_converter.convertUntyped (pout);
      if (!pnew)
      {
        REPORT_MESSAGE (MSG::WARNING)
          << "Pointer conversion from " << m_converter.srcName() << " to "
          << m_converter.dstName() << "failed.";
        m_associator->releaseElementUntyped (pout);
        continue;
      }
 
      m_index->push_back (m_map.findIndex (pnew));
    }
    m_associator->releaseElementUntyped (pout);
  }

Variable Documentation

◆ again

bool D3PD::again

Initial value:

{
  if (again)
    return fillAgain()

Definition at line 78 of file VoidBlockFillerTool.cxx.

◆ eventFlagNames

const EventFlagNames D3PD::eventFlagNames[]

static

Initial value:

                                           = {
  { xAOD::EventInfo::Pixel,      "pixel" },
  { xAOD::EventInfo::SCT,        "sct"   },
  { xAOD::EventInfo::TRT,        "trt"   },
  { xAOD::EventInfo::LAr,        "lar"   },
  { xAOD::EventInfo::Tile,       "tile"  },
  { xAOD::EventInfo::Muon,       "muon"  },
  { xAOD::EventInfo::ForwardDet, "fwd"   },
  { xAOD::EventInfo::Core,       "core"  },
}

Definition at line 31 of file EventFlagNames.h.

                                             {
  { xAOD::EventInfo::Pixel,      "pixel" },
  { xAOD::EventInfo::SCT,        "sct"   },
  { xAOD::EventInfo::TRT,        "trt"   },
  { xAOD::EventInfo::LAr,        "lar"   },
  { xAOD::EventInfo::Tile,       "tile"  },
  { xAOD::EventInfo::Muon,       "muon"  },
  { xAOD::EventInfo::ForwardDet, "fwd"   },
  { xAOD::EventInfo::Core,       "core"  },
};

◆ m_allowMissing

bool D3PD::m_allowMissing

Property: Don't give an error if the target getter fails to find the input objects.

Property: If true, the input object is allowed to be missing.

Definition at line 149 of file IndexAssociationFillerTool.h.

◆ m_blockFillers

ToolHandleArray<IBlockFillerTool> D3PD::m_blockFillers

private

Property: The list of block filler tools.

Definition at line 189 of file VectorFillerToolBase.h.

◆ m_blockName

std::string D3PD::m_blockName

Property: the name of this block.

Definition at line 142 of file IndexAssociationFillerTool.h.

◆ m_converter

TypeConverter D3PD::m_converter

Helper to convert from pointer returned by the associator to pointer into the index container.

Definition at line 156 of file IndexAssociationFillerTool.h.

◆ m_dr

float* D3PD::m_dr

private

Variable: DR to associated object.

Definition at line 112 of file DRAssociationTool.h.

◆ m_drcut

float D3PD::m_drcut

private

Property: DR cut.

Definition at line 109 of file DRAssociationTool.h.

◆ m_getter

ToolHandle< ICollectionGetterTool > D3PD::m_getter

private

Property: The collection getter tool.

Property: The getter for the target collection.

Definition at line 135 of file VectorFillerTool.h.

◆ m_index

std::vector< int > * D3PD::m_index

Index variable.

Index collection variable.

Definition at line 152 of file IndexAssociationFillerTool.h.

◆ m_map

IndexMap D3PD::m_map

Map from objects to indices.

Definition at line 159 of file IndexAssociationFillerTool.h.

◆ m_metadata

ObjectMetadata D3PD::m_metadata

protected

Metadata about the variables created by this tool.

Definition at line 180 of file VectorFillerToolBase.h.

◆ m_next

D3PD::m_next = m_associator->nextUntyped()

Definition at line 175 of file ContainedMultiAssociationFillerTool.cxx.

◆ m_nobj

int* D3PD::m_nobj

private

Variable for the object count.

Definition at line 210 of file VectorFillerToolBase.h.

◆ m_nobjName

std::string D3PD::m_nobjName

private

Property: Name of the variable for the count of objects. Omitted if empty.

Definition at line 197 of file VectorFillerToolBase.h.

◆ m_nrow

int* D3PD::m_nrow

private

Variable for the row count.

Definition at line 207 of file VectorFillerToolBase.h.

◆ m_nrowName

std::string D3PD::m_nrowName

private

Property: Name of the variable for the count of rows. Omitted if empty.

Definition at line 193 of file VectorFillerToolBase.h.

◆ m_objectName

std::string D3PD::m_objectName

private

Property: the name of the D3PDObject that created this tool.

Definition at line 138 of file VectorFillerTool.h.

◆ m_objIndex

int* D3PD::m_objIndex

private

Variable for the object index.

Definition at line 213 of file VectorFillerToolBase.h.

◆ m_objIndexName

std::string D3PD::m_objIndexName

private

Property: Name of the variable for the object index. Omitted if empty.

Definition at line 201 of file VectorFillerToolBase.h.

◆ m_prefix

std::string D3PD::m_prefix

Property: The variable name prefix.

Property: Variable prefix for this block.

Definition at line 139 of file IndexAssociationFillerTool.h.

◆ m_registry

ToolHandle< ICollectionGetterRegistryTool > D3PD::m_registry

Property: The ICollectionGetterRegistryTool instance.

Definition at line 145 of file IndexAssociationFillerTool.h.

◆ m_saveMetadata

bool D3PD::m_saveMetadata

private

Property: If true, the metadata about the variables is saved.

Definition at line 144 of file VectorFillerTool.h.

◆ m_targetLabel

std::string D3PD::m_targetLabel

Fill one block.

Parameters

p	The input object.
again	Set if this is a subsequent call requested by an AGAIN return

This is called once per object. The type of the object at which p points is given by the ti argument to configureD3PD. The caller is responsible for arranging that all the pointers for booked variables are set appropriately upon entry.

If the return status is the special code AGAIN (defined above), then this filler tool wants to make multiple entries. The parent should set up to capture a new `row' and run through the list of block filler tools again, but for this tool call fillAgainUntyped instead of fillUntyped. This should be repeated as long as fillAgainUntyped returns AGAIN.

Once fillUntyped returns AGAIN, the parent should call fillUntyped with the same p argument and again set to true. This continues until fillUntyped returns something other than AGAIN.

Not all parents may support this. In that case, returning AGAIN will be treated as an error. */ virtual StatusCode fillUntyped (const void* p, bool again = false) override;

private: / Property: The association tool instance. ToolHandle<ISingleAssociationTool> m_associator;

/** Property: The label of the collection getter defining the collection within which to index.

Parameters

p	The input object.
again	Set if this is a subsequent call requested by an AGAIN return

This is called once per object. The type of the object at which p points is given by the ti argument to configureD3PD. The caller is responsible for arranging that all the pointers for booked variables are set appropriately upon entry.

If the return status is the special code AGAIN (defined above), then this filler tool wants to make multiple entries. The parent should set up to capture a new `row' and run through the list of block filler tools again, but for this tool call fillAgainUntyped instead of fillUntyped. This should be repeated as long as fillAgainUntyped returns AGAIN.

Once fillUntyped returns AGAIN, the parent should call fillUntyped with the same p argument and again set to true. This continues until fillUntyped returns something other than AGAIN.

Not all parents may support this. In that case, returning AGAIN will be treated as an error. */ virtual StatusCode fillUntyped (const void* p, bool again = false) override;

private: / Property: The association tool instance. ToolHandle<IMultiAssociationTool> m_associator;

/** Property: The label of the collection getter defining the collection within which to index.

Definition at line 136 of file IndexAssociationFillerTool.h.

◆ m_tree

IAddVariable * D3PD::m_tree

private

Pointer to the ID3PD object used.

The parent tree.

Definition at line 147 of file VectorFillerTool.h.

◆ m_vars

Vars D3PD::m_vars

private

All booked variables.

Definition at line 346 of file VectorFillerToolBase.h.

◆ nEventFlagNames

size_t D3PD::nEventFlagNames

staticconstexpr

Initial value:

=

sizeof(eventFlagNames) / sizeof(eventFlagNames[0])

D3PD::eventFlagNames

static const EventFlagNames eventFlagNames[]

Definition EventFlagNames.h:31

Definition at line 42 of file EventFlagNames.h.

◆ pout

const void* D3PD::pout = m_associator->getUntyped (p)

Definition at line 161 of file IndexAssociationFillerTool.cxx.

◆ scout

D3PD::scout = StatusCode(scout.getCode())

Definition at line 155 of file ContainedAssociationFillerTool.cxx.

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ ButFirstType_t

◆ Types

Function Documentation

◆ addDimensionedVariable()

◆ addVariable()

◆ againok() [1/3]

◆ againok() [2/3]

◆ againok() [3/3]

◆ AmgSymMatrix() [1/2]

◆ AmgSymMatrix() [2/2]

◆ ATLAS_NOT_THREAD_SAFE() [1/2]

◆ ATLAS_NOT_THREAD_SAFE() [2/2]

◆ book()

◆ CHECK() [1/2]

◆ CHECK() [2/2]

◆ clidToTypeinfo()

◆ configureD3PD() [1/2]

◆ configureD3PD() [2/2]

◆ ContainedVectorMultiAssociationFillerTool()

◆ doBook()

◆ doConfigure()

◆ doFill()

◆ DRAssociationTool()

◆ fill()

◆ fillOnce()

◆ finalize()

◆ for()

◆ get() [1/2]

◆ get() [2/2]

◆ handle()

◆ if() [1/3]

◆ if() [2/3]

◆ if() [3/3]

◆ IndexAssociationFillerTool()

◆ IndexMultiAssociationFillerTool()

◆ initialize()

◆ isContainerFiller()

◆ maybeExtend()

◆ multiTypeInfo() [1/3]

◆ multiTypeInfo() [2/3]

◆ multiTypeInfo() [3/3]

◆ nameToCLID()

◆ nameToTypeinfo()

◆ operator+()

◆ releaseElementUntyped()

◆ releaseObjectUntyped()

◆ scout()

◆ typeinfoToName()

◆ VectorFillerTool()

◆ VectorFillerToolBase()

◆ while()

Variable Documentation

◆ again

◆ eventFlagNames

◆ m_allowMissing

◆ m_blockFillers

◆ m_blockName

◆ m_converter

◆ m_dr

◆ m_drcut

◆ m_getter

◆ m_index

◆ m_map

◆ m_metadata

◆ m_next

◆ m_nobj

◆ m_nobjName

◆ m_nrow

◆ m_nrowName

◆ m_objectName

◆ m_objIndex

◆ m_objIndexName

◆ m_prefix