TRTOverlay Class Reference

#include <TRTOverlay.h>

Inheritance diagram for TRTOverlay:

Collaboration diagram for TRTOverlay:

Public Member Functions
	TRTOverlay (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override final
virtual StatusCode	execute (const EventContext &ctx) const override final
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	overlayContainer (const EventContext &ctx, const TRT_RDO_Container *bkgContainer, const TRT_RDO_Container *signalContainer, TRT_RDO_Container *outputContainer, const InDetSimDataCollection *signalSDOCollection, DataPool< TRT_LoLumRawData > &dataItemsPool) const
void	mergeCollections (TRT_RDO_Collection *bkgCollection, TRT_RDO_Collection *signalCollection, TRT_RDO_Collection *outputCollection, double occupancy, const InDetSimDataCollection *signalSDOCollection, const TRTCond::StrawStatusData *strawStatusHT, CLHEP::HepRandomEngine *rndmEngine) const
	Here we take 2 view containers with elements owned by the DataPool we modify some of them and push them to a 3rd view container.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const TRT_ID *	m_trtId {}
Gaudi::Property< bool >	m_sortBkgInput
SG::ReadHandleKey< TRT_RDO_Container >	m_bkgInputKey
SG::ReadHandleKey< TRT_RDO_Container >	m_signalInputKey
SG::WriteHandleKey< TRT_RDO_Container >	m_outputKey
SG::ReadHandleKey< InDetSimDataCollection >	m_signalInputSDOKey
SG::ReadCondHandleKey< TRTCond::StrawStatusData >	m_strawStatusHTKey
ServiceHandle< IAthRNGSvc >	m_rndmSvc
Gaudi::Property< double >	m_HTOccupancyCorrectionB
Gaudi::Property< double >	m_HTOccupancyCorrectionEC
Gaudi::Property< double >	m_HTOccupancyCorrectionB_noE
Gaudi::Property< double >	m_HTOccupancyCorrectionEC_noE
Gaudi::Property< double >	m_HTOccupancyCorrectionB_Ar
Gaudi::Property< double >	m_HTOccupancyCorrectionEC_Ar
Gaudi::Property< double >	m_HTOccupancyCorrectionB_Ar_noE
Gaudi::Property< double >	m_HTOccupancyCorrectionEC_Ar_noE
ToolHandle< InDet::ITRT_LocalOccupancy >	m_TRT_LocalOccupancyTool
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

Friends
class	OverlayTesting::TRTOverlay_test

Detailed Description

Definition at line 32 of file TRTOverlay.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

TRTOverlay()

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

Definition at line 64 of file TRTOverlay.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 TRTOverlay::execute ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 101 of file TRTOverlay.cxx.

{
  ATH_MSG_DEBUG("execute() begin");
 
  // Reading the input RDOs
  const TRT_RDO_Container *bkgContainerPtr = nullptr;
  if (!m_bkgInputKey.empty()) {
    SG::ReadHandle<TRT_RDO_Container> bkgContainer(m_bkgInputKey, ctx);
    if (!bkgContainer.isValid()) {
      ATH_MSG_ERROR("Could not get background TRT RDO container " << bkgContainer.name() << " from store " << bkgContainer.store());
      return StatusCode::FAILURE;
    }
    bkgContainerPtr = bkgContainer.cptr();
 
    ATH_MSG_DEBUG("Found background TRT RDO container " << bkgContainer.name() << " in store " << bkgContainer.store());
    ATH_MSG_DEBUG("TRT Background = " << Overlay::debugPrint(bkgContainer.cptr()));
  }
 
  SG::ReadHandle<TRT_RDO_Container> signalContainer(m_signalInputKey, ctx);
  if (!signalContainer.isValid()) {
    ATH_MSG_ERROR("Could not get signal TRT RDO container " << signalContainer.name() << " from store " << signalContainer.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Found signal TRT RDO container " << signalContainer.name() << " in store " << signalContainer.store());
  ATH_MSG_DEBUG("TRT Signal     = " << Overlay::debugPrint(signalContainer.cptr()));
 
  SG::ReadHandle<InDetSimDataCollection> signalSDOContainer(m_signalInputSDOKey, ctx);
  if (!signalSDOContainer.isValid()) {
    ATH_MSG_ERROR("Could not get signal TRT SDO map container " << signalSDOContainer.name() << " from store " << signalSDOContainer.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Found signal TRT SDO map container " << signalSDOContainer.name() << " in store " << signalSDOContainer.store());
 
  // The DataPool, this is what will actually own the elements
  // we create during this algorithm. The containers are
  // views.
  DataPool<TRT_LoLumRawData> dataItemsPool(ctx);
  dataItemsPool.prepareToAdd(200000);
 
  // Creating output RDO container
  SG::WriteHandle<TRT_RDO_Container> outputContainer(m_outputKey, ctx);
  ATH_CHECK(outputContainer.record(std::make_unique<TRT_RDO_Container>(signalContainer->size())));
  if (!outputContainer.isValid()) {
    ATH_MSG_ERROR("Could not record output TRT RDO container " << outputContainer.name() << " to store " << outputContainer.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Recorded output TRT RDO container " << outputContainer.name() << " in store " << outputContainer.store());
 
  ATH_CHECK(overlayContainer(ctx, bkgContainerPtr, signalContainer.cptr(),
                             outputContainer.ptr(), signalSDOContainer.cptr(),
                             dataItemsPool));
  ATH_MSG_DEBUG(
      "TRT Result   = " << Overlay::debugPrint(outputContainer.ptr()));
 
  ATH_MSG_DEBUG("execute() end");
  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();
  }

initialize()

StatusCode TRTOverlay::initialize ( )

finaloverridevirtual

Definition at line 69 of file TRTOverlay.cxx.

{
  ATH_MSG_DEBUG("Initializing...");
 
  // Check and initialize keys
  ATH_CHECK( m_bkgInputKey.initialize(!m_bkgInputKey.key().empty()) );
  ATH_MSG_VERBOSE("Initialized ReadHandleKey: " << m_bkgInputKey);
  ATH_CHECK( m_signalInputKey.initialize() );
  ATH_MSG_VERBOSE("Initialized ReadHandleKey: " << m_signalInputKey);
  ATH_CHECK( m_outputKey.initialize() );
  ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputKey);
  ATH_CHECK( m_signalInputSDOKey.initialize() );
  ATH_MSG_VERBOSE("Initialized ReadHandleKey for SDO: " << m_signalInputSDOKey);
  ATH_CHECK( m_strawStatusHTKey.initialize() );
  ATH_MSG_VERBOSE("Initialized ReadCondHandleKey: " << m_strawStatusHTKey);
 
  // Retrieve TRT ID helper
  if (!detStore()->retrieve(m_trtId, "TRT_ID").isSuccess() || !m_trtId) {
    ATH_MSG_FATAL("Cannot retrieve TRT ID helper");
    return StatusCode::FAILURE;
  }
 
  // Initialize random number generator
  CHECK(m_rndmSvc.retrieve());
 
  // Retrieve TRT local occupancy tool
  CHECK(m_TRT_LocalOccupancyTool.retrieve());
 
  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 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;
}

mergeCollections()

void TRTOverlay::mergeCollections ( TRT_RDO_Collection * bkgCollection, TRT_RDO_Collection * signalCollection, TRT_RDO_Collection * outputCollection, double occupancy, const InDetSimDataCollection * signalSDOCollection, const TRTCond::StrawStatusData * strawStatusHT, CLHEP::HepRandomEngine * rndmEngine ) const

private

Here we take 2 view containers with elements owned by the DataPool we modify some of them and push them to a 3rd view container.

Definition at line 288 of file TRTOverlay.cxx.

{
  if (bkgCollection->identify() != signalCollection->identify()) {
    throw std::runtime_error("mergeCollections(): collection Id mismatch");
  }
 
  // Merge by copying ptrs from background and signal to output collection
  TRT_RDO_Collection::size_type ibkg = 0, isig = 0;
 
  outputCollection->reserve(
      std::max(bkgCollection->size(), signalCollection->size()));
  // Below we have swapElements.
  // Remember the elements of the signalCollection and bkgCollection
  // containers are owned by the DataPool.
  // tmpBkg and tmp are whaterver elements we take out of the containers.
  //
  // So
  // A) We can not delete them. dataPool will do that at the end of the event.
  // B) We can push them back only to a View so outputCollection is a view
  // collection
  // C) We pass nullptr so no need to get another item from the pool
 
  while ((ibkg < bkgCollection->size()) || (isig < signalCollection->size())) {
    // The RDO that goes to the output at the end of this step.
    TRT_RDORawData *tmp{};
 
    if (isig == signalCollection->size()) {
      // just copy the remaining background digits
      bkgCollection->swapElement(ibkg++, nullptr, tmp);
    } else if (ibkg == bkgCollection->size()) {
      // just copy the remaining signal digits
      signalCollection->swapElement(isig++, nullptr, tmp);
    } else {
      // Need to decide which one goes first.
      // See comments in TRTDigitization.cxx about the assumption that id1<id2 <=> hash1<hash2
      if (signalCollection->at(isig)->identify() < bkgCollection->at(ibkg)->identify()) {
        signalCollection->swapElement(isig++, nullptr, tmp);
      } else if (bkgCollection->at(ibkg)->identify() < signalCollection->at(isig)->identify()) {
        bkgCollection->swapElement(ibkg++, nullptr, tmp);
      } else {
        // The hits are on the same channel.
        TRT_RDORawData *tmpBkg{};
 
        bkgCollection->swapElement(ibkg++, nullptr, tmpBkg);
        signalCollection->swapElement(isig++, nullptr, tmp);
 
        TRT_LoLumRawData *sigRdo = dynamic_cast<TRT_LoLumRawData *>(tmp);
        const TRT_LoLumRawData *bkgRdo = dynamic_cast<const TRT_LoLumRawData *>(tmpBkg);
 
        if (sigRdo && bkgRdo) {
          // the actual merging
          sigRdo->merge(*bkgRdo);
 
          // If the hit is not already a high level hit
          if (!(sigRdo->getWord() & 0x04020100)) {
            // Determine if the hit is from an electron or not
            bool isElectron = false;
            Identifier rdoId = sigRdo->identify();
            InDetSimDataCollection::const_iterator sdoIter = signalSDOCollection->find(rdoId);
            if (sdoIter != signalSDOCollection->end()) {
              const std::vector<InDetSimData::Deposit> &deposits = sdoIter->second.getdeposits();
              for (const InDetSimData::Deposit &deposit : deposits) {
                const HepMcParticleLink &particleLink = deposit.first;
                if (particleLink.isValid()) {
                  if (std::abs(particleLink->pdg_id()) == 11) {
                    isElectron = true;
                    break;
                  }
                }
              }
            }
 
            // Determine what type of straw was hit
            bool isXenonStraw = false;
            if (strawStatusHT != nullptr) {
              if (strawStatusHT->findStatus(m_trtId->straw_hash(rdoId)) == TRTCond::StrawStatus::Good) {
                isXenonStraw = true;
              }
            }
 
            // Get random number
            int det = m_trtId->barrel_ec(rdoId);
            float HTOccupancyCorrection = 0.;
            if (isXenonStraw) {
              if (isElectron) {
                HTOccupancyCorrection = std::abs(det) > 1 ? m_HTOccupancyCorrectionEC : m_HTOccupancyCorrectionB;
              } else {
                HTOccupancyCorrection = std::abs(det) > 1 ? m_HTOccupancyCorrectionEC_noE : m_HTOccupancyCorrectionB_noE;
              }
            } else {
              if (isElectron) {
                HTOccupancyCorrection = std::abs(det) > 1 ? m_HTOccupancyCorrectionEC_Ar : m_HTOccupancyCorrectionB_Ar;
              } else {
                HTOccupancyCorrection = std::abs(det) > 1 ? m_HTOccupancyCorrectionEC_Ar_noE : m_HTOccupancyCorrectionB_Ar_noE;
              }
            }
 
            unsigned int newWord = 0;
            if (HTOccupancyCorrection != 0. && occupancy * HTOccupancyCorrection > CLHEP::RandFlat::shoot(rndmEngine, 0, 1)) {
              newWord += 1 << (26-9);
            }
 
            TRT_LoLumRawData newRdo(rdoId, newWord);
            sigRdo->merge(newRdo);
          }
        } else {
          ATH_MSG_WARNING("TRT RDO is the wrong format");
        }
      }
    }
 
    outputCollection->push_back(tmp);
  } // <= while
}

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.

overlayContainer()

StatusCode TRTOverlay::overlayContainer ( const EventContext & ctx, const TRT_RDO_Container * bkgContainer, const TRT_RDO_Container * signalContainer, TRT_RDO_Container * outputContainer, const InDetSimDataCollection * signalSDOCollection, DataPool< TRT_LoLumRawData > & dataItemsPool ) const

private

Definition at line 160 of file TRTOverlay.cxx.

{
 
  // There are some use cases where background is empty
  if (!bkgContainer) {
    // Only loop through the signal collections and copy them over
    for (const auto &[hashId, ptr] : signalContainer->GetAllHashPtrPair()) {
      // Copy the signal collection
      // pools own the individual elements
      std::unique_ptr<TRT_RDO_Collection> signalCollection = copyCollection(hashId, ptr, dataItemsPool);
 
      if (outputContainer->addCollection(signalCollection.get(), hashId).isFailure()) {
        ATH_MSG_ERROR("Adding signal Collection with hashId " << hashId << " failed");
        return StatusCode::FAILURE;
      } else {
        (void)signalCollection.release();
      }
    }
 
    return StatusCode::SUCCESS;
  }
 
  // Setup the random engine
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
  rngWrapper->setSeed( name(), ctx );
  CLHEP::HepRandomEngine *rndmEngine = rngWrapper->getEngine(ctx);
 
  // Load TRT conditions
  SG::ReadCondHandle<TRTCond::StrawStatusData> strawStatusHTHandle{ m_strawStatusHTKey, ctx };
  const TRTCond::StrawStatusData *strawStatusHT{*strawStatusHTHandle};
 
  // Retrieve the occupancy map
  std::map<int, double> occupancyMap = m_TRT_LocalOccupancyTool->getDetectorOccupancy(ctx, bkgContainer);
 
  // The MC signal container should typically be smaller than bkgContainer,
  // because the latter contains all the noise, minimum bias and pile up.
  // Thus we firstly iterate over signal hashes and store them in a map.
  std::vector < std::pair<IdentifierHash, bool> > overlapMap;
  overlapMap.reserve(signalContainer->numberOfCollections());
  for (const auto &[hashId, ptr] : signalContainer->GetAllHashPtrPair()) {
    overlapMap.emplace_back(hashId, false);
  }
 
  // Now loop through the background hashes and copy unique ones over
  for (const auto &[hashId, ptr] : bkgContainer->GetAllHashPtrPair()) {
    auto search = std::lower_bound( overlapMap.begin(), overlapMap.end(), hashId,
     [](const std::pair<IdentifierHash, bool> &lhs,  IdentifierHash rhs) -> bool { return lhs.first < rhs; } );
    if (search == overlapMap.end() || search->first != hashId) {
      // Copy the background collection
      std::unique_ptr<TRT_RDO_Collection> bkgCollection{};
      if (m_sortBkgInput) {
        // copy the bkg again Pool owns the individual elements
        bkgCollection = copyCollectionAndSort(hashId, bkgContainer->indexFindPtr(hashId),dataItemsPool);
      } else {
        bkgCollection = copyCollection(hashId, bkgContainer->indexFindPtr(hashId),dataItemsPool);
      }
 
      if (outputContainer->addCollection(bkgCollection.get(), hashId).isFailure()) {
        ATH_MSG_ERROR("Adding background Collection with hashId " << hashId << " failed");
        return StatusCode::FAILURE;
      } else {
        (void)bkgCollection.release();
      }
    } else {
      // Flip the overlap flag
      search->second = true;
    }
  }
 
  // Finally loop through the map and process the signal and overlay if
  // necessary
  for (const auto &[hashId, overlap] : overlapMap) {
    // Copy the signal collection the pool owns the individual elements
    std::unique_ptr<TRT_RDO_Collection> signalCollection =
        copyCollection(hashId, signalContainer->indexFindPtr(hashId),dataItemsPool);
 
    if (overlap) { // Do overlay
      // Create the output collection, only works for Inner Detector
      auto outputCollection = std::make_unique<TRT_RDO_Collection>(hashId);
      outputCollection->setIdentifier(signalCollection->identify());
      // This will receive merged elements from the other containers.
      // There elements are owned actually by the DataPool
      outputCollection->clear(SG::VIEW_ELEMENTS);
 
      // Copy the background collection the pool owns the individual elements
      std::unique_ptr<TRT_RDO_Collection> bkgCollection{};
      if (m_sortBkgInput) {
        bkgCollection = copyCollectionAndSort(hashId, bkgContainer->indexFindPtr(hashId),dataItemsPool);
      } else {
        bkgCollection = copyCollection(hashId, bkgContainer->indexFindPtr(hashId),dataItemsPool);
      }
 
      // Merge collections
      int det = m_trtId->barrel_ec(signalCollection->identify());
      mergeCollections(bkgCollection.get(),
                       signalCollection.get(),
                       outputCollection.get(),
                       occupancyMap[det],
                       signalSDOCollection,
                       strawStatusHT,
                       rndmEngine);
 
      if (outputContainer->addCollection(outputCollection.get(), hashId).isFailure()) {
        ATH_MSG_ERROR("Adding overlaid Collection with hashId " << hashId << " failed");
        return StatusCode::FAILURE;
      } else {
        outputCollection.release();
      }
    } else { // Only write signal out
      if (outputContainer->addCollection(signalCollection.get(), hashId).isFailure()) {
        ATH_MSG_ERROR("Adding signal Collection with hashId " << hashId << " failed");
        return StatusCode::FAILURE;
      } else {
        (void)signalCollection.release();
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

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

Friends And Related Symbol Documentation

OverlayTesting::TRTOverlay_test

friend class OverlayTesting::TRTOverlay_test

friend

Definition at line 34 of file TRTOverlay.h.

Member Data Documentation

m_bkgInputKey

SG::ReadHandleKey<TRT_RDO_Container> TRTOverlay::m_bkgInputKey

private

Initial value:

{
      this, "BkgInputKey", "Bkg_TRT_RDOs",
      " ReadHandleKey for Background Input TRT_RDO_Container"}

Definition at line 62 of file TRTOverlay.h.

                                                  {
      this, "BkgInputKey", "Bkg_TRT_RDOs",
      " ReadHandleKey for Background Input TRT_RDO_Container"};

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_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_HTOccupancyCorrectionB

Gaudi::Property<double> TRTOverlay::m_HTOccupancyCorrectionB

private

Initial value:

{
      this, "TRT_HT_OccupancyCorrectionBarrel", 0.110, ""}

Definition at line 82 of file TRTOverlay.h.

                                                {
      this, "TRT_HT_OccupancyCorrectionBarrel", 0.110, ""};

m_HTOccupancyCorrectionB_Ar

Gaudi::Property<double> TRTOverlay::m_HTOccupancyCorrectionB_Ar

private

Initial value:

{
      this, "TRT_HT_OccupancyCorrectionBarrelAr", 0.100, ""}

Definition at line 90 of file TRTOverlay.h.

                                                   {
      this, "TRT_HT_OccupancyCorrectionBarrelAr", 0.100, ""};

m_HTOccupancyCorrectionB_Ar_noE

Gaudi::Property<double> TRTOverlay::m_HTOccupancyCorrectionB_Ar_noE

private

Initial value:

{
      this, "TRT_HT_OccupancyCorrectionBarrelArNoE", 0.088, ""}

Definition at line 94 of file TRTOverlay.h.

                                                       {
      this, "TRT_HT_OccupancyCorrectionBarrelArNoE", 0.088, ""};

m_HTOccupancyCorrectionB_noE

Gaudi::Property<double> TRTOverlay::m_HTOccupancyCorrectionB_noE

private

Initial value:

{
      this, "TRT_HT_OccupancyCorrectionBarrelNoE", 0.060, ""}

Definition at line 86 of file TRTOverlay.h.

                                                    {
      this, "TRT_HT_OccupancyCorrectionBarrelNoE", 0.060, ""};

m_HTOccupancyCorrectionEC

Gaudi::Property<double> TRTOverlay::m_HTOccupancyCorrectionEC

private

Initial value:

{
      this, "TRT_HT_OccupancyCorrectionEndcap", 0.090, ""}

Definition at line 84 of file TRTOverlay.h.

                                                 {
      this, "TRT_HT_OccupancyCorrectionEndcap", 0.090, ""};

m_HTOccupancyCorrectionEC_Ar

Gaudi::Property<double> TRTOverlay::m_HTOccupancyCorrectionEC_Ar

private

Initial value:

{
      this, "TRT_HT_OccupancyCorrectionEndcapAr", 0.101, ""}

Definition at line 92 of file TRTOverlay.h.

                                                    {
      this, "TRT_HT_OccupancyCorrectionEndcapAr", 0.101, ""};

m_HTOccupancyCorrectionEC_Ar_noE

Gaudi::Property<double> TRTOverlay::m_HTOccupancyCorrectionEC_Ar_noE

private

Initial value:

{
      this, "TRT_HT_OccupancyCorrectionEndcapArNoE", 0.102, ""}

Definition at line 96 of file TRTOverlay.h.

                                                        {
      this, "TRT_HT_OccupancyCorrectionEndcapArNoE", 0.102, ""};

m_HTOccupancyCorrectionEC_noE

Gaudi::Property<double> TRTOverlay::m_HTOccupancyCorrectionEC_noE

private

Initial value:

{
      this, "TRT_HT_OccupancyCorrectionEndcapNoE", 0.050, ""}

Definition at line 88 of file TRTOverlay.h.

                                                     {
      this, "TRT_HT_OccupancyCorrectionEndcapNoE", 0.050, ""};

m_outputKey

SG::WriteHandleKey<TRT_RDO_Container> TRTOverlay::m_outputKey

private

Initial value:

{
      this, "OutputKey", "TRT_RDOs",
      "WriteHandleKey for Output TRT_RDO_Container"}

Definition at line 68 of file TRTOverlay.h.

                                                 {
      this, "OutputKey", "TRT_RDOs",
      "WriteHandleKey for Output TRT_RDO_Container"};

m_rndmSvc

ServiceHandle<IAthRNGSvc> TRTOverlay::m_rndmSvc

private

Initial value:

{this, "RndmSvc", "AthRNGSvc",
                                      "Random Number Service"}

Definition at line 79 of file TRTOverlay.h.

                                     {this, "RndmSvc", "AthRNGSvc",
                                      "Random Number Service"};

m_signalInputKey

SG::ReadHandleKey<TRT_RDO_Container> TRTOverlay::m_signalInputKey

private

Initial value:

{
      this, "SignalInputKey", "Sig_TRT_RDOs",
      "ReadHandleKey for Signal Input TRT_RDO_Container"}

Definition at line 65 of file TRTOverlay.h.

                                                     {
      this, "SignalInputKey", "Sig_TRT_RDOs",
      "ReadHandleKey for Signal Input TRT_RDO_Container"};

m_signalInputSDOKey

SG::ReadHandleKey<InDetSimDataCollection> TRTOverlay::m_signalInputSDOKey

private

Initial value:

{
      this, "SignalInputSDOKey", "Sig_TRT_SDO_Map",
      "ReadHandleKey for Signal Input InDetSimDataCollection for TRT"}

Definition at line 71 of file TRTOverlay.h.

                                                             {
      this, "SignalInputSDOKey", "Sig_TRT_SDO_Map",
      "ReadHandleKey for Signal Input InDetSimDataCollection for TRT"};

m_sortBkgInput

Gaudi::Property<bool> TRTOverlay::m_sortBkgInput

private

Initial value:

{this, "SortBkgInput", false,
                                       "Sort background input RDOs"}

Definition at line 59 of file TRTOverlay.h.

                                    {this, "SortBkgInput", false,
                                       "Sort background input RDOs"};

m_strawStatusHTKey

SG::ReadCondHandleKey<TRTCond::StrawStatusData> TRTOverlay::m_strawStatusHTKey

private

Initial value:

{
      this, "StrawStatusHT", "StrawStatusHTData", "StrawStatusHT key"}

Definition at line 74 of file TRTOverlay.h.

                                                                {
      this, "StrawStatusHT", "StrawStatusHTData", "StrawStatusHT key"};

m_TRT_LocalOccupancyTool

ToolHandle<InDet::ITRT_LocalOccupancy> TRTOverlay::m_TRT_LocalOccupancyTool

private

Initial value:

{
      this, "TRT_LocalOccupancyTool", "TRT_LocalOccupancy", ""}

Definition at line 98 of file TRTOverlay.h.

                                                               {
      this, "TRT_LocalOccupancyTool", "TRT_LocalOccupancy", ""};

m_trtId

const TRT_ID* TRTOverlay::m_trtId {}

private

Definition at line 57 of file TRTOverlay.h.

{};

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:

• TRTOverlay.h
• TRTOverlay.cxx