LVL1::eFakeTower Class Reference

Load Et of the test vector. More...

#include <eFakeTower.h>

Inheritance diagram for LVL1::eFakeTower:

Collaboration diagram for LVL1::eFakeTower:

Public Member Functions
	eFakeTower (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual StatusCode	init (const std::string &)
	initiate with the path to the test vector directory
	~eFakeTower ()
	Destructor.
virtual int	getET (int FPGAid, int eta, int phi, int layer, int cell) const
	obtain the Et of a tower slot
virtual StatusCode	loadnext ()
	Load the test vector of the next event.
virtual StatusCode	execute ()
	replace the Tower Et with the ones stored in the test vector.
virtual StatusCode	seteTowers (eTowerContainer *)
	Define the eTowerContainer object for which the Et will be replaced.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	changeFPGAET (int tmp_eTowersIDs_subset[][6], int FPGAnumber, int eFEXnumber)
	Replace the Et in an FOGA by the ones in the test vector.
StatusCode	loadFPGA (int)
	load the Et in an FPGA
StatusCode	loaddic (int)
	load index of Et
StatusCode	changeTowerET (LVL1::eTower *inputtower, int eta, int phi, int FPGAid) const
	Replace the Et in a tower by the ones in the test vector.
int	getFPGAnumber (int iefex, int ifpga) const
	determine the index of an FPGA
std::vector< int > *	loadBlock (const std::string &, int) const
	Load the Et or index in a block.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
eTowerContainer *	m_eTowerContainer {}
int	m_numberofevents {}
	number of events
ToolHandle< eFEXFPGATowerIdProvider >	m_eFEXFPGATowerIdProviderTool {this, "eFEXFPGATowerIdProviderTool", "LVL1::eFEXFPGATowerIdProvider", "Tool that provides tower-FPGA mapping"}
	tool needed for tower-FPGA mapping
std::string	m_inputfile
	path to the input directory
std::unordered_map< int, std::unordered_map< int, unsigned int > * >	m_alltowers
	map of all supercell ETs of FPGAs m_alltowers[FPGAid] = (supercell id,ET) supercell id = eta * 1000 + phi * 100 + layer * 10 + cell
std::unordered_map< int, std::vector< int > * >	m_dict
	map for mapping infomation. m_dict[FPGAid] = [ list of supercell id in order ]
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

Load Et of the test vector.

Replace the Et in all towers with the ones store in test vector files for the validation of the L1Calo simulation.

The test vector files should be keep in one single directory. The Et of each FPGA should be stored in separate files. The file name should be ***.csv where The first two digits are the index of the eFEX (0-23) while the third digit is the index of the FPGA (0-3).

The Et will be set to zero if the file of an FPGA cannot be found.

The index of the Et should be defined in the first block of the test vector and the other blocks define Et of each event. An example of the test vector can be found in /athena/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/share/testvectorexample.txt.

Definition at line 51 of file eFakeTower.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

eFakeTower()

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

Constructor.

Definition at line 15 of file eFakeTower.cxx.

                                                                                                :
  AthAlgTool(type, name, parent)
{
  declareInterface<eFakeTower>(this);
}

~eFakeTower()

LVL1::eFakeTower::~eFakeTower

(

)

Destructor.

Definition at line 21 of file eFakeTower.cxx.

                            {
  for (auto& allfpga : m_alltowers) {
    delete allfpga.second;
  }
  for (auto& allfpga : m_dict) {
    delete allfpga.second;
  }
  m_alltowers.clear();
}

Member Function Documentation

changeFPGAET()

StatusCode LVL1::eFakeTower::changeFPGAET ( int tmp_eTowersIDs_subset[][6], int FPGAnumber, int eFEXnumber )

private

Replace the Et in an FOGA by the ones in the test vector.

Parameters

tmp_eTowersIDs_subset	Array of tower IDs in the FPGA
FPGAnumber	FPGA index to locate the FPGA
eFEXnumber	eFEX index to locate the FPGA

Returns

status code

Definition at line 136 of file eFakeTower.cxx.

                                                                                                      {
  // replace all supercell energies in the FPGA using the test vector.
  for (int myrow = 0; myrow<10; myrow++){
    for (int mycol = 0; mycol<6; mycol++){
      LVL1::eTower* thistower = m_eTowerContainer->findTower(tmp_eTowersIDs_subset[myrow][mycol]);
      
      // ignore umpty FPGA
      bool nothaveFPGA = m_dict.find(getFPGAnumber(eFEXnumber, FPGAnumber)) == m_dict.end();
      if (nothaveFPGA) {
        continue;
      }
 
      ATH_CHECK( changeTowerET(thistower, mycol, myrow, getFPGAnumber(eFEXnumber, FPGAnumber)) );
    }
  }
  return StatusCode::SUCCESS;
}

changeTowerET()

StatusCode LVL1::eFakeTower::changeTowerET ( LVL1::eTower * inputtower, int eta, int phi, int FPGAid ) const

private

Replace the Et in a tower by the ones in the test vector.

Parameters

inputtower	eTower object to be processed
eta	eta index to locate the SuperCell
phi	phi index to locate the SuperCell
FPGAid	FPGA Id to locate the SuperCell

Returns

status code

Definition at line 154 of file eFakeTower.cxx.

                                                                                                   {
  // update the ETs of the eTower using the values of test vector.
  inputtower->clearET();
 
  inputtower->setET(0 ,getET(FPGAid, eta, phi, 0, 0), 0);
 
  inputtower->setET(1, getET(FPGAid, eta, phi, 1, 0), 1);
  inputtower->setET(2, getET(FPGAid, eta, phi, 1, 1), 1);
  inputtower->setET(3, getET(FPGAid, eta, phi, 1, 2), 1);
  inputtower->setET(4, getET(FPGAid, eta, phi, 1, 3), 1);
 
  inputtower->setET(5, getET(FPGAid, eta, phi, 2, 0), 2);
  inputtower->setET(6, getET(FPGAid, eta, phi, 2, 1), 2);
  inputtower->setET(7, getET(FPGAid, eta, phi, 2, 2), 2);
  inputtower->setET(8, getET(FPGAid, eta, phi, 2, 3), 2);
 
  inputtower->setET(9, getET(FPGAid, eta, phi, 3, 0), 3);
 
  inputtower->setET(10, getET(FPGAid, eta, phi, 4, 0), 4);
  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; }

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

execute()

StatusCode LVL1::eFakeTower::execute ( )

virtual

replace the Tower Et with the ones stored in the test vector.

Definition at line 99 of file eFakeTower.cxx.

                                   {
    int FPGAtowerids[10][6];
 
  // set the Et of all towers to zero first
  for (int efex{ 0 }; efex < 24; efex++) {
    for (int fpga{ 0 }; fpga < 4; fpga++) {
      StatusCode sc = m_eFEXFPGATowerIdProviderTool->getRankedTowerIDinFPGA(efex, fpga, FPGAtowerids);
      if (sc ==  StatusCode::FAILURE) {
        return StatusCode::FAILURE;
      }
      for (int myrow = 0; myrow<10; myrow++){
        for (int mycol = 0; mycol<6; mycol++){
          LVL1::eTower* thistower = m_eTowerContainer->findTower(FPGAtowerids[myrow][mycol]);
          thistower->clearET();
        }
      }
    }
  }
  
  // replace all supercell energies in the eTowerContainer using the test vector.
  for (int efex{ 0 }; efex < 24; efex++) {
    for (int fpga{ 0 }; fpga < 4; fpga++) {
      StatusCode sc = m_eFEXFPGATowerIdProviderTool->getRankedTowerIDinFPGA(efex, fpga, FPGAtowerids);
      if (sc ==  StatusCode::FAILURE) {
        return StatusCode::FAILURE;
      }
      ATH_CHECK( changeFPGAET(FPGAtowerids, fpga, efex) );
    }
  }
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

getET()

int LVL1::eFakeTower::getET ( int FPGAid, int eta, int phi, int layer, int cell ) const

virtual

obtain the Et of a tower slot

Parameters

FPGAid	FPGA id
eta	eta index of the tower (0-5)
phi	phi index of the tower (0-9)
layer	layer (0-4)
cell	tower slot. (pre-sample, layer-4 and had: 0, layer-2 and layer-3: 0-3)

Returns

Et

Definition at line 49 of file eFakeTower.cxx.

                                                                                 {
  // find the ET of a supercell.
  if (eta > 5 || eta < 0) {
    ATH_MSG_ERROR( "Requested Supercell does not exist.");
    return 0;
  }
  if (phi > 9 || phi < 0) {
    ATH_MSG_ERROR( "Requested Supercell does not exist.");
    return 0;
  }
  if (layer > 4 || layer < 0) {
    ATH_MSG_ERROR( "Requested Supercell does not exist.");
    return 0;
  }
  if (cell > 3 || cell < 0) {
    ATH_MSG_ERROR( "Requested Supercell does not exist.");
    return 0;
  }
  if (m_dict.find(FPGAid) == m_dict.end()) {
    return 0;
  }
  int id = eta * 1000 + phi * 100 + layer * 10 + cell;
  if (m_alltowers.at(FPGAid)->find(id) == m_alltowers.at(FPGAid)->end()) {
    ATH_MSG_ERROR( "Trying to access uninitiated supercell.");
    return 0;
  }
  return m_alltowers.at(FPGAid)->at(id);
}

getFPGAnumber()

int LVL1::eFakeTower::getFPGAnumber ( int iefex, int ifpga ) const

private

determine the index of an FPGA

Parameters

iefex	Id of the eFEX module (0-23)
ifpga	Id of the FPGA (0-3)

Returns

FPGA index

Definition at line 244 of file eFakeTower.cxx.

                                                            {
  return iefex * 10 + ifpga;
}

init()

StatusCode LVL1::eFakeTower::init ( const std::string & input_fileadress )

virtual

initiate with the path to the test vector directory

Definition at line 31 of file eFakeTower.cxx.

                                                                 {
  ATH_CHECK( m_eFEXFPGATowerIdProviderTool.retrieve() );
  m_numberofevents = 0;
  m_inputfile = input_fileadress;
  std::string txt = ".txt";
  for (int efex{ 0 }; efex < 24; efex++) {
    for (int fpga{ 0 }; fpga < 4; fpga++) {
      std::fstream fileStream;
      fileStream.open(m_inputfile + std::to_string(getFPGAnumber(efex, fpga)) + txt);
      if (fileStream.fail()) {
          continue;
      }
      ATH_CHECK( loaddic(getFPGAnumber(efex, fpga)) );
    }
  }
  return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

interfaceID()

const InterfaceID & LVL1::eFakeTower::interfaceID ( )

inlinestatic

Definition at line 56 of file eFakeTower.h.

{ return IID_IeFakeTower; };

loadBlock()

std::vector< int > * LVL1::eFakeTower::loadBlock ( const std::string & inputfile, int eventnumber ) const

private

Load the Et or index in a block.

Definition at line 209 of file eFakeTower.cxx.

                                                                                           {
  // load the eventnumber_th block of the input file.
  std::string eachline;
  std::ifstream myfile(inputfile);
  std::vector<int>* output = new std::vector<int>;
  if (myfile.is_open()) {
    int nblock = 0;
    while (std::getline(myfile, eachline)) {
      // The blocks are separated by empty lines.
      if (eachline.length() < 3) {
        nblock++;
      }
      if (nblock < eventnumber) {
        continue;
      }
      else if (nblock > eventnumber) {
        break;
      }
      std::string temvalue;
      std::stringstream ss(eachline);
      while (ss >> temvalue) {
        // the first block is always the dic
        if (eventnumber == 0) {
          output->push_back(std::stoi(temvalue));
        } else {
          int et = eFEXCompression::expand(int(strtoull(temvalue.c_str(), nullptr, 16)));
          output->push_back(et);
        }
      }
    }
    myfile.close();
  }
  return output;
}

loaddic()

StatusCode LVL1::eFakeTower::loaddic ( int FPGAid )

private

load index of Et

Definition at line 201 of file eFakeTower.cxx.

                                             {
  // load mapping information and store it in the m_dict object.
  std::string txt = ".txt";
  std::vector<int>* dic0 = loadBlock(m_inputfile + std::to_string(FPGAid) + txt, 0);
  m_dict.insert(std::make_pair(FPGAid, dic0));
  return StatusCode::SUCCESS;
}

loadFPGA()

StatusCode LVL1::eFakeTower::loadFPGA ( int FPGAid )

private

load the Et in an FPGA

Definition at line 176 of file eFakeTower.cxx.

                                              {
  std::string txt = ".txt";
  // load ETs of an FPGA and store them in m_alltowers.
 
  // Check if the mapping exists.
  if (m_dict.find(FPGAid) == m_dict.end()) {
    ATH_MSG_ERROR( "Mapping for FPGA "<< FPGAid << " does not exist!");
    return StatusCode::FAILURE;
  }
  std::unique_ptr<std::vector<int>> Ets{loadBlock(m_inputfile + std::to_string(FPGAid) + txt, m_numberofevents)};
 
  // check if the vector ETs have the same size as the mapping vector.
  if (Ets->size() != (*m_dict[FPGAid]).size()) {
    ATH_MSG_ERROR( "Unable to finish the tower mapping!" );
    return StatusCode::FAILURE;
  }
  std::unordered_map<int, unsigned int>* ETmap = new std::unordered_map<int, unsigned int>;
  for (size_t i{};const auto &thisEt : *Ets){
    ETmap->emplace((*m_dict[FPGAid])[i++], thisEt);
  }
  m_alltowers[FPGAid] = ETmap;
  return StatusCode::SUCCESS;
}

loadnext()

StatusCode LVL1::eFakeTower::loadnext ( )

virtual

Load the test vector of the next event.

Definition at line 78 of file eFakeTower.cxx.

{
  m_numberofevents++;
  // load the next events.
  for (auto& allfpga : m_alltowers) {
    delete allfpga.second;
  }
  std::string txt = ".txt";
  for (int efex{ 0 }; efex < 24; efex++) {
    for (int fpga{ 0 }; fpga < 4; fpga++) {
      std::fstream fileStream;
      fileStream.open(m_inputfile + std::to_string(getFPGAnumber(efex, fpga)) + txt);
      if (fileStream.fail()) {
          continue;
      }
      ATH_CHECK( loadFPGA(getFPGAnumber(efex, fpga)) );
    }
  }
  return StatusCode::SUCCESS;
}

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

seteTowers()

StatusCode LVL1::eFakeTower::seteTowers ( eTowerContainer * input )

virtual

Define the eTowerContainer object for which the Et will be replaced.

Definition at line 131 of file eFakeTower.cxx.

                                                            {
  m_eTowerContainer = input;
  return StatusCode::SUCCESS;
}

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_alltowers

std::unordered_map<int, std::unordered_map<int, unsigned int>*> LVL1::eFakeTower::m_alltowers

private

map of all supercell ETs of FPGAs m_alltowers[FPGAid] = (supercell id,ET) supercell id = eta * 1000 + phi * 100 + layer * 10 + cell

Definition at line 146 of file eFakeTower.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_dict

std::unordered_map<int, std::vector<int>*> LVL1::eFakeTower::m_dict

private

map for mapping infomation. m_dict[FPGAid] = [ list of supercell id in order ]

Definition at line 149 of file eFakeTower.h.

m_eFEXFPGATowerIdProviderTool

ToolHandle<eFEXFPGATowerIdProvider> LVL1::eFakeTower::m_eFEXFPGATowerIdProviderTool {this, "eFEXFPGATowerIdProviderTool", "LVL1::eFEXFPGATowerIdProvider", "Tool that provides tower-FPGA mapping"}

private

tool needed for tower-FPGA mapping

Definition at line 137 of file eFakeTower.h.

{this, "eFEXFPGATowerIdProviderTool", "LVL1::eFEXFPGATowerIdProvider", "Tool that provides tower-FPGA mapping"};

m_eTowerContainer

eTowerContainer* LVL1::eFakeTower::m_eTowerContainer {}

private

Definition at line 129 of file eFakeTower.h.

{}; //the eTowerContainer object for which the Et will be replaced

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_inputfile

std::string LVL1::eFakeTower::m_inputfile

private

path to the input directory

Definition at line 139 of file eFakeTower.h.

m_numberofevents

int LVL1::eFakeTower::m_numberofevents {}

private

number of events

Definition at line 134 of file eFakeTower.h.

{}; 

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• eFakeTower.h
• eFakeTower.cxx