GlobalSim::Egamma1_OnlineMapNbhood Class Reference

#include <Egamma1_OnlineMapNbhood.h>

Inheritance diagram for GlobalSim::Egamma1_OnlineMapNbhood:

Collaboration diagram for GlobalSim::Egamma1_OnlineMapNbhood:

Public Member Functions
	Egamma1_OnlineMapNbhood (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
	initialize function running before the first event
virtual StatusCode	execute (const EventContext &) const override
	execute function running for every event
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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	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

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	findNeighborhoods_OnlineMap (const std::vector< const xAOD::eFexEMRoI * > &, const GlobalSim::GlobalLArCellContainer &, std::vector< bool > &, IOBitwise::eEmNbhoodTOBContainer &) const
	Function to produce mutliple windows from a vector of incoming eFeX RoIs.
StatusCode	findNeighborhood_OnlineMap (const xAOD::eFexEMRoI *, const GlobalSim::GlobalLArCellContainer &, bool &, IOBitwise::eEmNbhoodTOBContainer &) const
	Function to produce a window from an incoming eFeX RoI.
bool	findSeedCell (float, float, const GlobalSim::GlobalLArCellContainer &, Identifier &) const
	Function to find the seed cell for a window from the eFeX RoI position.
bool	findHalfStrips (int, float, float, const GlobalSim::GlobalLArCellContainer &, Identifier &) const
	Function to search for seed cells according to local granularity.
StatusCode	findWindow (IdentifierHash, const GlobalSim::GlobalLArCellContainer &, std::vector< std::vector< std::shared_ptr< const GlobalSim::GlobalLArCell > > > &) const
	Function to produce a window around an input seed cell.
StatusCode	findMaxima (IdentifierHash &, std::vector< std::vector< std::shared_ptr< const GlobalSim::GlobalLArCell > > > &) const
	Function to find the maximum energy cell in a window.
std::shared_ptr< const GlobalLArCell >	findMax (std::vector< std::shared_ptr< const GlobalLArCell > > &) const
	Function to find the maximum energy cell in a vector of cells.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const CaloCell_ID *	m_calocell_id {}
const LArEM_ID *	m_larem_id {}
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey
	ReadHandle Key for the EventInfo object.
ToolHandle< eFexRoIAlgTool >	m_roiAlgTool
	ToolHandle for the eFexRoI AlgTool.
SG::ReadHandleKey< GlobalSim::GlobalLArCellContainer >	m_gblLArCellContainerKey
	ReadHandle Key to the GlobalLArCellContainer.
SG::WriteHandleKey< std::vector< float > >	m_eFEXetaKey
	WriteHandle Key for the eFexRoI's eta (for valid windows, for DEBUG).
SG::WriteHandleKey< std::vector< float > >	m_eFEXphiKey
	WriteHandle Key for the eFexRoI's phi (for valid windows, for DEBUG).
SG::WriteHandleKey< std::vector< float > >	m_FailedeFEXetaKey
	WriteHandle Key for the eFexRoI's eta (for invalid windows, for DEBUG).
SG::WriteHandleKey< std::vector< float > >	m_FailedeFEXphiKey
	WriteHandle Key for the eFexRoI's phi (for invalid windows, for DEBUG).
SG::WriteHandleKey< IOBitwise::eEmNbhoodTOBContainer >	m_neighKey
	WriteHandle Key for the resulting TOBs.
Gaudi::Property< bool >	m_dump
	Parameter to toggle dumping of full information window information.
Gaudi::Property< bool >	m_dumpTerse
	Parameter to toggle dumping of brief information window information.
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Definition at line 35 of file Egamma1_OnlineMapNbhood.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

Egamma1_OnlineMapNbhood()

GlobalSim::Egamma1_OnlineMapNbhood::Egamma1_OnlineMapNbhood	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 29 of file Egamma1_OnlineMapNbhood.cxx.

                                                                                                   : 
    AthReentrantAlgorithm(name, pSvcLocator){
  }

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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 GlobalSim::Egamma1_OnlineMapNbhood::execute ( const EventContext & ctx ) const

overridevirtual

execute function running for every event

Definition at line 70 of file Egamma1_OnlineMapNbhood.cxx.

                                                                           {
    
    ATH_MSG_DEBUG ("Executing");
 
    //Get EventInfo
    SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey, ctx);
    if(!eventInfo.isValid()) {
      ATH_MSG_ERROR ("Error obtaining EventInfo object");
      return StatusCode::FAILURE;
    }
 
    //Get GlobalLArCells
    auto h_gblLArCells = SG::makeHandle(m_gblLArCellContainerKey, ctx);
    CHECK(h_gblLArCells.isValid());
    const auto & gblLArCells = *h_gblLArCells;
    ATH_MSG_DEBUG(gblLArCells.size() <<"Cells read in");
 
    //Get eFeXRoIs
    std::vector<const xAOD::eFexEMRoI*> rois_in;
    CHECK(m_roiAlgTool->RoIs(rois_in, ctx));
    ATH_MSG_DEBUG(rois_in.size() << " RoI(s) read in");
 
    //Remove the RoIs in the barrel/endcap crack region (hopefully temporary)
    std::vector<const xAOD::eFexEMRoI*> rois;
    for(auto roi:rois_in){
      //Kill rois in the crack
      if(std::abs(roi->eta()) >= 1.37 && std::abs(roi->eta()) <= 1.52) continue;
      ATH_MSG_DEBUG ("Roi et " << roi->et());
      rois.push_back(roi);
    }
    
    // find GlobalLArCells in the neighborhood of RoIs.
    // A neighborhood is a collection of CellData objects which
    // contain cell eta, phi and Et.
 
    //Setup a container of TOBs with associated GlobalLArCell windows
    auto neighborhoodTOBs = std::make_unique<IOBitwise::eEmNbhoodTOBContainer>();
    //Flags for window finding success/failure
    std::vector<bool> successes;
 
    //Finw the windows for all of the valid incoming RoIs
    CHECK(findNeighborhoods_OnlineMap(rois, gblLArCells, successes, *neighborhoodTOBs));
 
    //Setup output for eFeXRoI eta/phi debug variables
    SG::WriteHandle<std::vector<float> > h_eFEXeta(m_eFEXetaKey, ctx);
    CHECK(h_eFEXeta.record(std::make_unique<std::vector<float> >()));
    SG::WriteHandle<std::vector<float> > h_eFEXphi(m_eFEXphiKey, ctx);
    CHECK(h_eFEXphi.record(std::make_unique<std::vector<float> >()));
 
    SG::WriteHandle<std::vector<float> > h_FailedeFEXeta(m_FailedeFEXetaKey, ctx);
    CHECK(h_FailedeFEXeta.record(std::make_unique<std::vector<float> >()));
    SG::WriteHandle<std::vector<float> > h_FailedeFEXphi(m_FailedeFEXphiKey, ctx);
    CHECK(h_FailedeFEXphi.record(std::make_unique<std::vector<float> >()));
 
    
    //Fill RoI eta/phi variables for valid windows
    for(int i=0; auto success:successes){
      if(success){
    h_eFEXeta->push_back(rois[i]->eta());
    h_eFEXphi->push_back(rois[i]->phi());
      } else {
    h_FailedeFEXeta->push_back(rois[i]->eta());
        h_FailedeFEXphi->push_back(rois[i]->phi());
      }
      i++;
    }
 
    //Setup the write out of the resultant TOBs
    SG::WriteHandle<GlobalSim::IOBitwise::eEmNbhoodTOBContainer> h_neighborhoodTOBs(m_neighKey, ctx);
 
    //Dump the window/RoI information to local files (for DEBUG)
    auto dumper = GlobalSim::LArStripNeighborhoodDumper();
    if(m_dump || m_dumpTerse){
      if (m_dump) {
        CHECK(dumper.dump(name(), *eventInfo, *neighborhoodTOBs));
      }
 
      if (m_dumpTerse) {
        CHECK(dumper.dumpTerse(name(), *eventInfo, *neighborhoodTOBs));
      }
    }
 
    //Write out the TOBs
    CHECK(h_neighborhoodTOBs.record(std::move(neighborhoodTOBs)));
    
    return StatusCode::SUCCESS;
  }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

findHalfStrips()

bool GlobalSim::Egamma1_OnlineMapNbhood::findHalfStrips ( int strip, float eta, float phi, const GlobalSim::GlobalLArCellContainer & cells, Identifier & CellID ) const

private

Function to search for seed cells according to local granularity.

Definition at line 341 of file Egamma1_OnlineMapNbhood.cxx.

                                                    {
    //Initialise variables
    bool found = false;
    //For each supercell there are different numbers of strips, this finds the midpoints.
    float half_strip = 0.025/strip/2;
    //Define the "inwards" direction 
    //int sign = 1;
    //if(eta < 0) sign = -1;
    int sign = std::copysign(1, eta);
    int halt = strip-1;
    //Starting at the inner centre strip, step through the allowed strips to find the
    //seed cell.
    for(int i=1;i<=halt;i+=2){
      found = findSeedCell(eta-(i*half_strip*sign), phi, cells, CellID);
      if(found) {
    ATH_MSG_DEBUG("We found it! Going in by " << (i+1)/2 << " eta: " << eta-(i*half_strip) << " phi: " << phi);
    return found;
      }
    }
    //If we didn't find the strip going inwards, look outwards instead.
    if(!found){
      for(int i=1;i<=halt;i+=2){
    found = findSeedCell(eta+(i*half_strip*sign), phi, cells, CellID);
    if(found) {
      ATH_MSG_DEBUG("We found it! Going out " << (i+1)/2 << " eta: " << eta+(i*half_strip) << " phi: " << phi);
      return found;
    }
      }
    }
    //Return if we failed to find a strip.
    return found;
  }

findMax()

std::shared_ptr< const GlobalLArCell > GlobalSim::Egamma1_OnlineMapNbhood::findMax ( std::vector< std::shared_ptr< const GlobalLArCell > > & row ) const

private

Function to find the maximum energy cell in a vector of cells.

Definition at line 592 of file Egamma1_OnlineMapNbhood.cxx.

                                                                                                                              {
    auto it = std::max_element(std::begin(row),
                               std::end(row),
                               [](const auto& l,const auto& r) {
                                 return l->getEnergy() < r->getEnergy();
                               });
    
    std::shared_ptr<const GlobalLArCell> max_cell{*it};
    return max_cell;
  }

findMaxima()

StatusCode GlobalSim::Egamma1_OnlineMapNbhood::findMaxima ( IdentifierHash & hashId, std::vector< std::vector< std::shared_ptr< const GlobalSim::GlobalLArCell > > > & window ) const

private

Function to find the maximum energy cell in a window.

Definition at line 565 of file Egamma1_OnlineMapNbhood.cxx.

                                                                                                 {
 
    //Vector to hold each row's maximum
    std::vector<std::shared_ptr<const GlobalLArCell>> maxima;
    //Loop over the rows and find each maximum energy cell.
    for(uint row = 0;row < window.size();row++){
      auto max_cell = Egamma1_OnlineMapNbhood::findMax(window[row]);
      maxima.push_back(max_cell);
      ATH_MSG_DEBUG("Found a max cell " << max_cell->getID() << " et " << max_cell->getEnergy() << " eta " << max_cell->eta() << " phi " << max_cell->phi()); 
    }
    //If we have two equal maxima, then take the middle row to be consistent.
    if((maxima[0]->getEnergy() == maxima[1]->getEnergy() && maxima[1]->getEnergy() >= maxima[2]->getEnergy())
       || (maxima[1]->getEnergy() == maxima[2]->getEnergy() && maxima[1]->getEnergy() >= maxima[0]->getEnergy())){
      ATH_MSG_DEBUG("Found the max cell " << maxima[1]->getID() << " et " << maxima[1]->getEnergy() << " eta " << maxima[1]->eta() << " phi " << maxima[1]->phi());
      hashId = m_calocell_id->calo_cell_hash(static_cast<Identifier>(maxima[1]->getID()));
      return StatusCode::SUCCESS;
    } else {
      //Otherwise just take the maximum cell.
      auto maximum_cell = Egamma1_OnlineMapNbhood::findMax(maxima);
      ATH_MSG_DEBUG("Found the max cell " << maximum_cell->getID() << " et " << maximum_cell->getEnergy() << " eta " << maximum_cell->eta() << " phi " << maximum_cell->phi()); 
      hashId = m_calocell_id->calo_cell_hash(static_cast<Identifier>(maximum_cell->getID()));
      return StatusCode::SUCCESS;
    }
  } 

findNeighborhood_OnlineMap()

StatusCode GlobalSim::Egamma1_OnlineMapNbhood::findNeighborhood_OnlineMap ( const xAOD::eFexEMRoI * roi, const GlobalSim::GlobalLArCellContainer & cells, bool & success, IOBitwise::eEmNbhoodTOBContainer & neighborhoodTOBs ) const

private

Function to produce a window from an incoming eFeX RoI.

Definition at line 213 of file Egamma1_OnlineMapNbhood.cxx.

                                                                                      {
    
    // Form the window, and set the vector sizes.
    auto window = std::vector<std::vector<std::shared_ptr<const GlobalLArCell>>>(3);
    window[0].resize(17);
    window[1].resize(17);
    window[2].resize(17);
 
    //Setup variables
    Identifier CellID;
    float eta = roi->eta();
    float phi = roi->phi();
    bool found = false;
    int strip = 0;
 
    //Tower position to find strip granularity
    int iEta = roi->iEta();
    int iPhi = roi->iPhi();
    ATH_MSG_DEBUG("Where is this RoI? eta: " << eta << " phi: " << phi << " iEta" << iEta << " iPhi " << iPhi);
    //There are 1 strips per 0.025 supercell at the edge.
    //Shouldn't need to shift these?
    if(iEta == -25 || iEta == 24) {
      //Just use the eta/phi as is, becasue there is only one strip here.
      found = findSeedCell(eta, phi, cells, CellID);
    }
    //There are 4 strips per 0.025 in these towers
    else if((iEta > -25 && iEta <= -21) || (iEta < 24 && iEta >= 20)){
      strip = 4;
    }
    //There are 6 strips per 0.025 in these towers
    else if((iEta > -21 && iEta <= -19) || (iEta < 20 && iEta >= 18)) {
      strip = 6;
    }
    //There are 8 strips per 0.025 in these towers, apart from the crack region where
    //here be dragons. The crack region is not currently dealt with.
    else if((iEta > -19 && iEta <=-1) || (iEta < 18 && iEta >=0)) {
      strip = 8;
    } else {
      //We shouldn't get here, but just in case...
      ATH_MSG_WARNING("Where are we? eta " << eta << " phi " << phi);
    }
    //
    if(strip != 0){
      //Send the number of strips information along with the eta/phi supercell.
      found = findHalfStrips(strip, eta, phi, cells, CellID);
    }
 
    //If we successfully found the seed cell, then continue.
    if(found){
      int ibec     = abs(m_larem_id->barrel_ec(CellID));   // 1 barrel 2 EC OW  3 EC IW
      int sampling = m_larem_id->sampling(CellID);
      int eta      = m_larem_id->eta(CellID);
      int phi      = m_larem_id->phi(CellID);
      int region   = m_larem_id->region(CellID);
      
      ATH_MSG_DEBUG("Where is this Seed? B/E? " << ibec << " sampling " << sampling << " eta " << eta << " phi " << phi << " region " << region);
            
      //Need the hash for the neighbours
      IdentifierHash hashId=m_calocell_id->calo_cell_hash(CellID);
      //Find the initial 17x3 eta/phi window
      ATH_CHECK(findWindow(hashId, cells, window));
      //Find the maxima in the window (only once!)
      ATH_CHECK(findMaxima(hashId, window));
      //Find the new 17x3 eta/phi window around this maxima
      ATH_CHECK(findWindow(hashId, cells, window));
 
      //Rediscover the maximum energy cell
      auto it = std::ranges::max_element(std::begin(window[1]),
                 std::end(window[1]),
                 [](const auto& l,const auto& r) {
                   return l->getEnergy() < r->getEnergy();
                 });
      
      std::shared_ptr<const GlobalLArCell> max_cell{*it};    
 
      //Function to fill the StripData for the neighbourhood
      auto toStripData = [](const auto& fromCells){
    auto stripdata = std::vector<StripData>();
    stripdata.reserve(fromCells.size());
    std::ranges::transform(std::begin(fromCells),
               std::end(fromCells),
               back_inserter(stripdata),
               [](const auto& c) {
             return StripData(c->eta(),
                      c->phi(),
                      c->getEnergy());});
    return stripdata;
      };
 
      //Check that we didn't lose the maximum energy cell
      auto max_neigh_cell_it = std::ranges::find(window[1],
                         max_cell);
      if (max_neigh_cell_it == std::end(window[1])){
    ATH_MSG_ERROR("Lost the max cell");
    return StatusCode::FAILURE;
      }
 
      //Find the position of the maximum energy cell in the neighbourhood.
      auto max_neigh_cell_pos{std::distance(std::begin(window[1]),
                        max_neigh_cell_it)};
 
      //Fill the StripData vectors
      auto low = toStripData(window[0]);
      auto center = toStripData(window[1]);
      auto high = toStripData(window[2]);
 
      //Fill the neighbourhood seed roi, and maximum cell positions.
      Coords roi_c{roi->eta(), roi->phi()};
      Coords cell_c{max_cell->eta(), max_cell->phi()};
 
      //Form the neighbourhood
      LArStripNeighborhood neighborhood = LArStripNeighborhood(low, center, high, roi_c, cell_c, max_neigh_cell_pos);
 
      //Add the neighbourhood to the list.
      neighborhoodTOBs.push_back(std::make_unique<IOBitwise::eEmNbhoodTOB>(*roi, neighborhood));
      success = true;
    } else {
      //If we didn't find the window, then tell us about it.
      ATH_MSG_DEBUG("Didn't find the RoI eta: " << roi->eta() << " phi: " << roi->phi());
    }    
    return StatusCode::SUCCESS;
  }

findNeighborhoods_OnlineMap()

StatusCode GlobalSim::Egamma1_OnlineMapNbhood::findNeighborhoods_OnlineMap ( const std::vector< const xAOD::eFexEMRoI * > & rois, const GlobalSim::GlobalLArCellContainer & cells, std::vector< bool > & successes, IOBitwise::eEmNbhoodTOBContainer & neighborhoodTOBs ) const

private

Function to produce mutliple windows from a vector of incoming eFeX RoIs.

Definition at line 162 of file Egamma1_OnlineMapNbhood.cxx.

                                                                                      {
    
    for (const auto& roi : rois) {
      ATH_MSG_DEBUG("roi et " << roi->et());
      bool success = false;
      ATH_CHECK(findNeighborhood_OnlineMap(roi, cells, success, neighborhoodTOBs));
      successes.push_back(success);
    }
    
    return StatusCode::SUCCESS;
  }

findSeedCell()

bool GlobalSim::Egamma1_OnlineMapNbhood::findSeedCell ( float eta, float phi, const GlobalSim::GlobalLArCellContainer & cells, Identifier & CellID ) const

private

Function to find the seed cell for a window from the eFeX RoI position.

Definition at line 382 of file Egamma1_OnlineMapNbhood.cxx.

                                                   {
 
    // Loop over the cells
    for(const GlobalSim::GlobalLArCell* cell :cells){
      // Find the layer one cells
      if(cell->getSampling() == 1 || cell->getSampling() == 5) {
    // Draw the boxes for each cell
    float etamin = cell->eta() - (0.5*cell->deta());
    float etamax = cell->eta() + (0.5*cell->deta());
    
    float phimin = cell->phi() - (0.5*cell->dphi());
    float phimax = cell->phi() + (0.5*cell->dphi());
 
    // Ask if the input lies within a box.
    if(etamin < eta && eta < etamax && phimin < phi && phi < phimax){
      // Return the cellID if we find a match
      CellID = cell->getID();
      ATH_MSG_DEBUG("Found the seed " << CellID << " eta "<< cell->eta() << " phi " << cell->phi() << " sampling " << m_larem_id->sampling(CellID));
      return true;
    }
      }
    }
    // Otherwise report that we failed to find a match.
    return false;
  }

findWindow()

StatusCode GlobalSim::Egamma1_OnlineMapNbhood::findWindow ( IdentifierHash hashId, const GlobalSim::GlobalLArCellContainer & cells, std::vector< std::vector< std::shared_ptr< const GlobalSim::GlobalLArCell > > > & window ) const

private

Function to produce a window around an input seed cell.

Definition at line 412 of file Egamma1_OnlineMapNbhood.cxx.

                                                                                                 {
 
    // If we pass in a Dummy ID we cannot start the process, fail gracefully for now.
    if(hashId == hashIdDummy) return StatusCode::SUCCESS;
 
    //Setup container for found neighbours.
    std::vector<IdentifierHash> neighbourList;
    //Setup next/previous hashIDs
    IdentifierHash hashIdNext;
    IdentifierHash hashIdPrev;
    //Initialise them to the input for the first loop.
    hashIdNext = hashIdPrev = hashId;
    //Position of the cell in each 17 long eta row. Defined by position in loop.
    int shift = 0;
    //Check if we have hit the edge of the detector.
    float etaMax = 0;
 
    ATH_MSG_DEBUG("Seed Hash: " << hashId);
    //Start loop to fill the central row of the 17x3 eta/phi window.
    for(int etaOffset = 0; etaOffset <=8; etaOffset++){
      ATH_MSG_DEBUG("Offset: " << etaOffset);
      //Rediscover the centre cell for the first step.
      if(etaOffset == 0){
    //This retrieves the cell from a hash map in the GlobalLArCell container.
    auto cell = cells.getCellFromHash(hashId);
    //Sanity check.
    if(cell != nullptr){
      //Fill the central neighbourhood position.
      window[1][8] = cell;
      ATH_MSG_DEBUG("Found the middle cell " << cell->getID() << " at eta " << cell->eta() << " phi " << cell->phi());
      //Start defining where we are in eta.
      etaMax = cell->eta();
    }   
      } else {
    //If we are not at the edge, and were not previously at the edge. Then...
    if(std::abs(etaMax) < 2.475 && hashIdNext != hashIdDummy){
      //Use the previous hashIDNext to look for the next cell in eta
      m_larem_id->get_neighbours(hashIdNext,LArNeighbours::nextInEta,neighbourList);
      ATH_MSG_DEBUG("Next in eta " << neighbourList[0] << " HashId " << hashId);
      //Grab the next cell hashID in eta and store it for the next step.
      hashIdNext = neighbourList[0];
      //Try to retrieve the cell from the hash map
      auto cellNext = cells.getCellFromHash(hashIdNext);
      //Define how steps we are away from the central cell
      shift = 8+etaOffset;
      //If the hash map contained the next cell.
      if(cellNext != nullptr){
        ATH_MSG_DEBUG("Found a cell " << cellNext->getID() << " at eta " << cellNext->eta() << " phi " << cellNext->phi());
        //update the eta position
        etaMax = cellNext->eta();
        //Put the found cell in the window
        window[1][shift] = cellNext;
      } else {
        //We didn't find the cell in the hash map. Put a dummy in the window.
        ATH_MSG_DEBUG("Putting in a next dummy with hashIdNext " << hashIdNext);
        window[1][shift] = std::make_shared<GlobalLArCell>(hashIdNext,"",0);
        //Potential issue if you cannot find the cell... but this cell would be the last in eta?
      }
    } else {
      //We are off the edge of the detector. Put in a Dummy cell to keep the window going.
      shift = 8+etaOffset;
      ATH_MSG_DEBUG("No next in eta: Putting in an empty DUMMY");
      window[1][shift] = std::make_shared<GlobalLArCell>(hashIdDummy,"",0);
    }
    //Now go inwards, as above, but with prevInEta, and no need to pad for the edge of the detector.
    m_larem_id->get_neighbours(hashIdPrev,LArNeighbours::prevInEta,neighbourList);
    ATH_MSG_DEBUG("Previous in eta " << neighbourList[0] << " hashId " << hashId);
    hashIdPrev = neighbourList[0];
    auto cellPrev = cells.getCellFromHash(hashIdPrev);
    shift = 8-etaOffset;
    if(cellPrev != nullptr){
      ATH_MSG_DEBUG("Found a cell " << cellPrev->getID() << " at eta " << cellPrev->eta() << " phi " << cellPrev->phi());
      window[1][shift] = cellPrev;
    } else {
      ATH_MSG_DEBUG("Putting in a previous dummy with hasIdPrev " << hashIdPrev);
      window[1][shift] = std::make_shared<GlobalLArCell>(hashIdPrev,"",0);
    }
      }
    }
 
    //We now have the central row. Loop to fill the phi rows above and below in phi.
    for(int phiOffset = 0; phiOffset <=1; phiOffset++){
      ATH_MSG_DEBUG("Offset: " << phiOffset);
      //First do nextInPhi
      if(phiOffset == 0){
    shift = 0;
    //Loop over the middle row.
    for(auto& windowCell:window[1]){
      ATH_MSG_DEBUG("Cell ID " << shift << " is " << windowCell->getID());
      //If this isn't a Dummy cell
      if(windowCell->getID() != hashIdDummy){
        //Find the cell hashID from its offline ID.
        IdentifierHash hashIdCurrent = m_calocell_id->calo_cell_hash(static_cast<Identifier>(windowCell->getID()));
        //There are cases where the CellID is the hashID. Update the hash to this.
        if(windowCell->getID() <= maxIdentifierHash) hashIdCurrent = windowCell->getID();
        //Proceed as in eta, finding next in Phi.
        m_larem_id->get_neighbours(hashIdCurrent,LArNeighbours::nextInPhi,neighbourList);
        ATH_MSG_DEBUG("Next in phi " << neighbourList[0] << " hashId " << hashIdCurrent);
        //Find the hashID and use it to look up the cell in the hash map.
        hashIdCurrent = neighbourList[0];
        auto cellCurrent = cells.getCellFromHash(hashIdCurrent);
        //If we find the cell in the hash map
        if(cellCurrent != nullptr){
          //Put the cell in the window.
          ATH_MSG_DEBUG("Found a cell " << cellCurrent->getID() << " at eta " << cellCurrent->eta() << " phi " << cellCurrent->phi());
          window[0][shift] = cellCurrent;
        } else {
          //Put a dummy cell. No need to get the ID right here.
          ATH_MSG_DEBUG("No next in phi: Last HashIdCurrent " << hashIdCurrent);
          window[0][shift] = std::make_shared<GlobalLArCell>(hashIdDummy,"",0);
        }
        shift++;
      } else {
        //We found a Dummy in the middle row, put a dummy in next phi too.
        ATH_MSG_DEBUG("No next in phi: Putting in a DUMMY");
        window[0][shift] = std::make_shared<GlobalLArCell>(hashIdDummy,"",0);
        shift++;
      }
    }
      } else {
    //Repeat the above for the previous row in Phi
    shift = 0;
    for(auto& windowCell:window[1]){
      ATH_MSG_DEBUG("Cell ID " << shift << " is " << windowCell->getID());
      if(windowCell->getID() != hashIdDummy){
        IdentifierHash hashIdCurrent = m_calocell_id->calo_cell_hash(static_cast<Identifier>(windowCell->getID()));
        if(windowCell->getID() <= maxIdentifierHash) hashIdCurrent = windowCell->getID();
        m_larem_id->get_neighbours(hashIdCurrent,LArNeighbours::prevInPhi,neighbourList);
        ATH_MSG_DEBUG("Previous in phi " << neighbourList[0] << " hashId " << hashIdCurrent);
        hashIdCurrent = neighbourList[0];
        auto cellCurrent = cells.getCellFromHash(hashIdCurrent);
        if(cellCurrent != nullptr){
          ATH_MSG_DEBUG("Found a cell " << cellCurrent->getID() << " at eta " << cellCurrent->eta() << " phi " << cellCurrent->phi());
          window[2][shift] = cellCurrent;
        } else {
          ATH_MSG_DEBUG("No prev in phi: Putting in a DUMMY");
          window[2][shift] = std::make_shared<GlobalLArCell>(hashIdDummy,"",0);
        }
        shift++;
      } else {
        ATH_MSG_DEBUG("No prev in phi: Putting in a DUMMY");
            window[2][shift] = std::make_shared<GlobalLArCell>(hashIdDummy,"",0);
            shift++;
          }
    }
      }
    }
    return StatusCode::SUCCESS;
  }

initialize()

StatusCode GlobalSim::Egamma1_OnlineMapNbhood::initialize ( )

overridevirtual

initialize function running before the first event

Definition at line 39 of file Egamma1_OnlineMapNbhood.cxx.

                                                 {
    ATH_MSG_DEBUG ("Initializing " << name());
 
    //Input keys
    CHECK(m_eventInfoKey.initialize());
    CHECK(m_gblLArCellContainerKey.initialize());
    CHECK(m_roiAlgTool.retrieve());
    //Output keys
    CHECK(m_neighKey.initialize());
    CHECK(m_eFEXetaKey.initialize());
    CHECK(m_eFEXphiKey.initialize());
    CHECK(m_FailedeFEXetaKey.initialize());
    CHECK(m_FailedeFEXphiKey.initialize());
    
    // retrieve ID helpers
    ATH_CHECK(detStore()->retrieve(m_calocell_id, "CaloCell_ID"));
 
    //Launch the calorimeter ID managers
    const CaloIdManager* caloIdMgr = nullptr;
    StatusCode sc = detStore()->retrieve(caloIdMgr);
    if (sc.isFailure()) {
      ATH_MSG_ERROR(" Unable to retrieve CaloIdManager from DetectoreStore");
      return StatusCode::FAILURE;
    }
    m_larem_id = caloIdMgr->getEM_ID();
    
    return StatusCode::SUCCESS;
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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_calocell_id

const CaloCell_ID* GlobalSim::Egamma1_OnlineMapNbhood::m_calocell_id {}

private

Definition at line 47 of file Egamma1_OnlineMapNbhood.h.

{};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_dump

Gaudi::Property<bool> GlobalSim::Egamma1_OnlineMapNbhood::m_dump

private

Initial value:

{
      this,
      "dump",
      false,
      "flag to enable dumps"}

Parameter to toggle dumping of full information window information.

Definition at line 111 of file Egamma1_OnlineMapNbhood.h.

                               {
      this,
      "dump",
      false,
      "flag to enable dumps"};

m_dumpTerse

Gaudi::Property<bool> GlobalSim::Egamma1_OnlineMapNbhood::m_dumpTerse

private

Initial value:

{
      this,
      "dumpTerse",
      false,
      "flag to enable terse dumps"}

Parameter to toggle dumping of brief information window information.

Definition at line 118 of file Egamma1_OnlineMapNbhood.h.

                                    {
      this,
      "dumpTerse",
      false,
      "flag to enable terse dumps"};

m_eFEXetaKey

SG::WriteHandleKey<std::vector<float> > GlobalSim::Egamma1_OnlineMapNbhood::m_eFEXetaKey

private

Initial value:

{
      this,
      "eFEXetaKey",
      "eFEXeta"}

WriteHandle Key for the eFexRoI's eta (for valid windows, for DEBUG).

Definition at line 75 of file Egamma1_OnlineMapNbhood.h.

                 {
      this,
      "eFEXetaKey",
      "eFEXeta"};

m_eFEXphiKey

SG::WriteHandleKey<std::vector<float> > GlobalSim::Egamma1_OnlineMapNbhood::m_eFEXphiKey

private

Initial value:

{
      this,
      "eFEXphiKey",
      "eFEXphi"}

WriteHandle Key for the eFexRoI's phi (for valid windows, for DEBUG).

Definition at line 82 of file Egamma1_OnlineMapNbhood.h.

                 {
      this,
      "eFEXphiKey",
      "eFEXphi"};

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> GlobalSim::Egamma1_OnlineMapNbhood::m_eventInfoKey

private

Initial value:

{
      this,
    "EventInfo",
    "EventInfo",
    "EventInfo name"}

ReadHandle Key for the EventInfo object.

Definition at line 51 of file Egamma1_OnlineMapNbhood.h.

                                                 {
      this,
    "EventInfo",
    "EventInfo",
    "EventInfo name"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_FailedeFEXetaKey

SG::WriteHandleKey<std::vector<float> > GlobalSim::Egamma1_OnlineMapNbhood::m_FailedeFEXetaKey

private

Initial value:

{
      this,
      "FailedeFEXetaKey",
      "FailedeFEXeta"}

WriteHandle Key for the eFexRoI's eta (for invalid windows, for DEBUG).

Definition at line 89 of file Egamma1_OnlineMapNbhood.h.

                       {
      this,
      "FailedeFEXetaKey",
      "FailedeFEXeta"};

m_FailedeFEXphiKey

SG::WriteHandleKey<std::vector<float> > GlobalSim::Egamma1_OnlineMapNbhood::m_FailedeFEXphiKey

private

Initial value:

{
      this,
      "FailedeFEXphiKey",
      "FailedeFEXphi"}

WriteHandle Key for the eFexRoI's phi (for invalid windows, for DEBUG).

Definition at line 96 of file Egamma1_OnlineMapNbhood.h.

                       {
      this,
      "FailedeFEXphiKey",
      "FailedeFEXphi"};

m_gblLArCellContainerKey

SG::ReadHandleKey<GlobalSim::GlobalLArCellContainer> GlobalSim::Egamma1_OnlineMapNbhood::m_gblLArCellContainerKey

private

Initial value:

{
      this,
      "GlobalLArCellsKey",
      "GlobalLArCells",
      "Key for the container of the LAr cells sent to Global"}

ReadHandle Key to the GlobalLArCellContainer.

Definition at line 67 of file Egamma1_OnlineMapNbhood.h.

                             {
      this,
      "GlobalLArCellsKey",
      "GlobalLArCells",
      "Key for the container of the LAr cells sent to Global"}; 

m_larem_id

const LArEM_ID* GlobalSim::Egamma1_OnlineMapNbhood::m_larem_id {}

private

Definition at line 48 of file Egamma1_OnlineMapNbhood.h.

{};

m_neighKey

SG::WriteHandleKey<IOBitwise::eEmNbhoodTOBContainer> GlobalSim::Egamma1_OnlineMapNbhood::m_neighKey

private

Initial value:

{
      this,
      "stripNeighborhoodTOBKey",
      "stripNeighborhoodTOBContainer",
      "location to write strip neighborhoods of EFex RoIs, with the associated TOBs"}

WriteHandle Key for the resulting TOBs.

Definition at line 103 of file Egamma1_OnlineMapNbhood.h.

               {
      this,
      "stripNeighborhoodTOBKey",
      "stripNeighborhoodTOBContainer",
      "location to write strip neighborhoods of EFex RoIs, with the associated TOBs"};

m_roiAlgTool

ToolHandle<eFexRoIAlgTool> GlobalSim::Egamma1_OnlineMapNbhood::m_roiAlgTool

private

Initial value:

{
      this,
      "roiAlgTool",
      "GlobalSim::eFexRoIAlgTool",
      "AlgTool to provide a vector<const xAOD::eFexEMRoI*>"}

ToolHandle for the eFexRoI AlgTool.

Definition at line 59 of file Egamma1_OnlineMapNbhood.h.

                {
      this,
      "roiAlgTool",
      "GlobalSim::eFexRoIAlgTool",
      "AlgTool to provide a vector<const xAOD::eFexEMRoI*>"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• Egamma1_OnlineMapNbhood.h
• Egamma1_OnlineMapNbhood.cxx