D3PD::VectorFillerToolBase Class Reference

Common code for wrapping filled variables up into a vector. More...

#include <VectorFillerToolBase.h>

Inheritance diagram for D3PD::VectorFillerToolBase:

Collaboration diagram for D3PD::VectorFillerToolBase:

Classes
class	Var
	Description for a single variable. More...
struct	Vars
	Description for the list of variables. More...

Public Member Functions
	VectorFillerToolBase (const std::string &type, const std::string &name, const IInterface *parent)
	Standard Gaudi tool constructor.
virtual StatusCode	initialize ()
	Standard Gaudi initialize method.
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.
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
template<class T>
StatusCode	addVariable (const std::string &name, T *&ptr, const std::string &docstring="")
	Add a variable to the tuple.
template<class T, class U>
StatusCode	addVariable (const std::string &name, T *&ptr, const std::string &docstring, const U &defval)
	Add a variable to the tuple.
template<class T>
StatusCode	addDimensionedVariable (const std::string &name, T *&ptr, const std::string &dim, const std::string &docstring="")
	Add a variable to the tuple.
template<class T, class U>
StatusCode	addDimensionedVariable (const std::string &name, T *&ptr, const std::string &dim, const std::string &docstring, const U &defval)
	Add a variable to the tuple.

Protected Member Functions
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	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.

Protected Attributes
ObjectMetadata	m_metadata
	Metadata about the variables created by this tool.
std::string	m_prefix
	Property: Variable prefix for this block.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
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.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
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.
std::string	m_nobjName
	Property: Name of the variable for the count of objects.
std::string	m_objIndexName
	Property: Name of the variable for the object index.
IAddVariable *	m_tree
	The parent tree.
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.
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

Common code for wrapping filled variables up into a vector.

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

Definition at line 77 of file VectorFillerToolBase.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

VectorFillerToolBase()

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

Standard Gaudi tool constructor.

Parameters

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.");
}

Member Function Documentation

addDimensionedVariable() [1/3]

template<class T, class U>

StatusCode D3PD::IAddVariable::addDimensionedVariable ( const std::string & name, T *& ptr, const std::string & dim, const std::string & docstring, const U & defval )

inherited

Add a variable to the tuple.

Parameters

name	The name 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. Only works for basic types.

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

addDimensionedVariable() [2/3]

template<class T>

StatusCode D3PD::IAddVariable::addDimensionedVariable ( const std::string & name, T *& ptr, const std::string & dim, const std::string & docstring = "" )

inherited

Add a variable to the tuple.

Parameters

name	The name 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.

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

addDimensionedVariable() [3/3]

StatusCode D3PD::VectorFillerToolBase::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.

Implements D3PD::IAddVariable.

Definition at line 383 of file VectorFillerToolBase.cxx.

{
  REPORT_MESSAGE(MSG::ERROR) << "addDimensionedVariable not yet implemented.";
  return StatusCode::FAILURE;
}

addVariable() [1/3]

template<class T, class U>

StatusCode D3PD::IAddVariable::addVariable ( const std::string & name, T *& ptr, const std::string & docstring, const U & defval )

inherited

Add a variable to the tuple.

Parameters

name	The name 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. Only works for basic types.

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

addVariable() [2/3]

template<class T>

StatusCode D3PD::IAddVariable::addVariable ( const std::string & name, T *& ptr, const std::string & docstring = "" )

inherited

Add a variable to the tuple.

Parameters

name	The name 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.

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

addVariable() [3/3]

StatusCode D3PD::VectorFillerToolBase::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.

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.

Implements D3PD::IAddVariable.

Definition at line 306 of file VectorFillerToolBase.cxx.

{
  if (!m_tree) {
    // Called from constructor --- just initialize pointer.
    ptr = 0;
    return StatusCode::SUCCESS;
  }
 
  // Default value handling.
  size_t defsize = 0;
  char* defcopied = 0;
  if (defval) {
    EDataType dt = TDataType::GetType (ti);
    switch (dt) {
    case kChar_t:
    case kUChar_t:
    case kShort_t:
    case kUShort_t:
    case kInt_t:
    case kUInt_t:
    case kLong_t:
    case kULong_t:
    case kFloat_t:
    case kDouble_t:
    case kDouble32_t:
    case kchar:
    case kBool_t:
    case kLong64_t:
    case kULong64_t:
    case kFloat16_t:
      // ok
      break;
 
    default:
      REPORT_MESSAGE (MSG::ERROR)
        << "Requested a default value for variable " << name
        << " of type " << System::typeinfoName (ti)
        << "; but default values are only supported for basic types.";
      return StatusCode::FAILURE;
    }
 
    TDataType* tdt = gROOT->GetType (TDataType::GetTypeName (dt));
    assert (tdt != 0);
    defsize = tdt->Size();
    defcopied = new char[defsize];
    std::memcpy (defcopied, defval, defsize);
  }
 
  m_vars.push_back (Var (name, ti, ptr, docstring, defcopied, defsize));
  CHECK( m_vars.back().init (&m_metadata, m_prefix) );
  CHECK( m_vars.back().init (m_tree, m_prefix) );
 
  return StatusCode::SUCCESS;
}

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; }

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;
}

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; }

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

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()

StatusCode D3PD::VectorFillerToolBase::finalize ( )

virtual

Standard Gaudi finalize method.

Definition at line 99 of file VectorFillerToolBase.cxx.

{
  // Don't clear the m_vars variable, because some memory will never be freed
  // in that case...
  return StatusCode::SUCCESS;
}

initialize()

StatusCode D3PD::VectorFillerToolBase::initialize ( )

virtual

Standard Gaudi initialize method.

Definition at line 88 of file VectorFillerToolBase.cxx.

{
  CHECK( AthAlgTool::initialize() );
  CHECK( m_blockFillers.retrieve() );
  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.

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);
  }
}

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.

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);
      }
    }
  }

Member Data Documentation

m_blockFillers

ToolHandleArray<IBlockFillerTool> D3PD::VectorFillerToolBase::m_blockFillers

private

Property: The list of block filler tools.

Definition at line 189 of file VectorFillerToolBase.h.

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_metadata

ObjectMetadata D3PD::VectorFillerToolBase::m_metadata

protected

Metadata about the variables created by this tool.

Definition at line 180 of file VectorFillerToolBase.h.

m_nobj

int* D3PD::VectorFillerToolBase::m_nobj

private

Variable for the object count.

Definition at line 210 of file VectorFillerToolBase.h.

m_nobjName

std::string D3PD::VectorFillerToolBase::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::VectorFillerToolBase::m_nrow

private

Variable for the row count.

Definition at line 207 of file VectorFillerToolBase.h.

m_nrowName

std::string D3PD::VectorFillerToolBase::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_objIndex

int* D3PD::VectorFillerToolBase::m_objIndex

private

Variable for the object index.

Definition at line 213 of file VectorFillerToolBase.h.

m_objIndexName

std::string D3PD::VectorFillerToolBase::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::VectorFillerToolBase::m_prefix

protected

Property: Variable prefix for this block.

Definition at line 184 of file VectorFillerToolBase.h.

m_tree

IAddVariable* D3PD::VectorFillerToolBase::m_tree

private

The parent tree.

Definition at line 204 of file VectorFillerToolBase.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vars

Vars D3PD::VectorFillerToolBase::m_vars

private

All booked variables.

Definition at line 346 of file VectorFillerToolBase.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:

• VectorFillerToolBase.h
• VectorFillerToolBase.cxx