SCT_PrepDataToxAOD Class Reference

#include <SCT_PrepDataToxAOD.h>

Inheritance diagram for SCT_PrepDataToxAOD:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	finalize () override
virtual bool	isClonable () const override
	Make this algorithm clonable.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
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
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
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
std::vector< std::vector< int > >	addSDOInformation (xAOD::TrackMeasurementValidation *xprd, const InDet::SCT_Cluster *prd, const InDetSimDataCollection *sdoCollection) const
	Decorate the cluster with SDO truth information and return, per RDO, the uniqueIDs of the truth particles that deposited charge in it.
void	addSiHitInformation (xAOD::TrackMeasurementValidation *xprd, const InDet::SCT_Cluster *prd, const std::vector< const SiHit * > *siHits, const std::vector< std::vector< int > > &sdoTruthUIDs) const
void	findAllHitsCompatibleWithCluster (const InDet::SCT_Cluster *prd, const std::vector< const SiHit * > *siHits, const std::vector< std::vector< int > > &sdoTruthUIDs, std::vector< SiHit > &matchingHits) const
void	addRDOInformation (xAOD::TrackMeasurementValidation *, const InDet::SCT_Cluster *, const std::map< Identifier, const SCT_RDORawData * > &idToRAWDataMap) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const SCT_ID *	m_SCTHelper {nullptr}
SG::ReadHandleKey< InDet::SCT_ClusterContainer >	m_clustercontainer {this, "SiClusterContainer", "SCT_Clusters"}
SG::ReadHandleKey< InDetSimDataCollection >	m_SDOcontainer {this, "MC_SDOs", "SCT_SDO_Map"}
SG::ReadHandleKey< SiHitCollection >	m_sihitContainer {this, "MC_Hits", "SCT_Hits"}
SG::ReadHandleKey< PRD_MultiTruthCollection >	m_multiTruth {this, "PRD_MultiTruth", "PRD_MultiTruthSCT"}
SG::ReadHandleKey< xAODTruthParticleLinkVector >	m_truthParticleLinks {this,"InputTruthParticleLinks","","The key for the truth particle link collection."}
SG::ReadHandleKey< SCT_RDO_Container >	m_rdoContainer {this, "SctRdoContainer", "SCT_RDOs"}
SG::WriteHandleKey< xAOD::TrackMeasurementValidationContainer >	m_xAodContainer {this, "SctxAodContainer", "SCT_Clusters"}
SG::WriteHandleKey< std::vector< unsigned int > >	m_xAodOffset {this, "SctxAodOffset", "SCT_ClustersOffsets"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
BooleanProperty	m_useTruthInfo {this, "UseTruthInfo", false}
BooleanProperty	m_writeRDOinformation {this, "WriteRDOinformation", true}
BooleanProperty	m_writeSDOs {this, "WriteSDOs", false}
BooleanProperty	m_writeSiHits {this, "WriteSiHits", false}
BooleanProperty	m_useSiHitsGeometryMatching
std::atomic< unsigned int >	m_haveTruthLink {}
std::atomic< unsigned int >	m_missingTruthParticle {}
std::atomic< unsigned int >	m_missingParentParticle {}
std::atomic_bool	m_firstEventWarnings {false}
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 44 of file SCT_PrepDataToxAOD.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

addRDOInformation()

void SCT_PrepDataToxAOD::addRDOInformation ( xAOD::TrackMeasurementValidation * xprd, const InDet::SCT_Cluster * prd, const std::map< Identifier, const SCT_RDORawData * > & idToRAWDataMap ) const

private

Definition at line 570 of file SCT_PrepDataToxAOD.cxx.

                                                                                                                  {
  std::vector<int> strip(prd->rdoList().size(), -1);
  std::vector<int> timebin(prd->rdoList().size(), -1);
  std::vector<int> groupsize(prd->rdoList().size(), -1);
 
  unsigned int nRDOs{0};
  for (const auto& hitIdentifier: prd->rdoList()) {
    auto result{idToRAWDataMap.find(hitIdentifier)};
    if (result != idToRAWDataMap.end()) {
      const SCT_RDORawData* sctRdo{result->second};
      if (sctRdo){
        strip[nRDOs] = m_SCTHelper->strip(sctRdo->identify());
        const SCT3_RawData* rdo3{dynamic_cast<const SCT3_RawData*>(sctRdo)};
        if (rdo3) {
          timebin[nRDOs] = rdo3->getTimeBin();
          groupsize[nRDOs] = rdo3->getGroupSize();
        }
      }
    }
    nRDOs++;
  }
  
  AUXDATA(xprd, std::vector<int>, rdo_strip) = std::move(strip);
  AUXDATA(xprd, std::vector<int>, rdo_timebin) = std::move(timebin);
  AUXDATA(xprd, std::vector<int>, rdo_groupsize) = std::move(groupsize);
}

addSDOInformation()

std::vector< std::vector< int > > SCT_PrepDataToxAOD::addSDOInformation ( xAOD::TrackMeasurementValidation * xprd, const InDet::SCT_Cluster * prd, const InDetSimDataCollection * sdoCollection ) const

private

Decorate the cluster with SDO truth information and return, per RDO, the uniqueIDs of the truth particles that deposited charge in it.

Definition at line 344 of file SCT_PrepDataToxAOD.cxx.

{
  std::vector<int> sdo_word;
  std::vector<std::vector<int>> sdo_depositsUniqueID;
  std::vector<std::vector<float>> sdo_depositsEnergy;
  // find hit
  for (const auto& hitIdentifier: prd->rdoList()) {
    auto pos{sdoCollection->find(hitIdentifier)};
    if (pos == sdoCollection->end()) continue;
    sdo_word.push_back(pos->second.word());
    std::vector<int> sdoDepUniqueID(pos->second.getdeposits().size(), HepMC::INVALID_PARTICLE_ID);
    std::vector<float> sdoDepEnergy(pos->second.getdeposits().size());
    unsigned int nDepos{0};
    for (auto& deposit: pos->second.getdeposits()) {
      if (deposit.first) sdoDepUniqueID[nDepos] = HepMC::uniqueID(deposit.first);
      ATH_MSG_DEBUG(" SDO Energy Deposit " << deposit.second);
      sdoDepEnergy[nDepos] = deposit.second;
      nDepos++;
    }
    sdo_depositsUniqueID.push_back(std::move(sdoDepUniqueID));
    sdo_depositsEnergy.push_back(std::move(sdoDepEnergy));
  }
  AUXDATA(xprd, std::vector<int>, sdo_words) = std::move(sdo_word);
  AUXDATA(xprd, std::vector<std::vector<int>>, sdo_depositsBarcode) = sdo_depositsUniqueID; // TODO rename variable to be consistent?
  AUXDATA(xprd, std::vector<std::vector<float>>, sdo_depositsEnergy) = std::move(sdo_depositsEnergy);
  return sdo_depositsUniqueID;
}

addSiHitInformation()

void SCT_PrepDataToxAOD::addSiHitInformation ( xAOD::TrackMeasurementValidation * xprd, const InDet::SCT_Cluster * prd, const std::vector< const SiHit * > * siHits, const std::vector< std::vector< int > > & sdoTruthUIDs ) const

private

Definition at line 375 of file SCT_PrepDataToxAOD.cxx.

{
  std::vector<SiHit> matchingHits;
  findAllHitsCompatibleWithCluster(prd, siHits, sdoTruthUIDs, matchingHits);
 
  long unsigned int numHits{matchingHits.size()};
 
  std::vector<float> sihit_energyDeposit(numHits, 0.);
  std::vector<float> sihit_meanTime(numHits, 0.);
  std::vector<int> sihit_uniqueID(numHits, HepMC::UNDEFINED_ID);
  
  std::vector<float> sihit_startPosX(numHits, 0.);
  std::vector<float> sihit_startPosY(numHits, 0.);
  std::vector<float> sihit_startPosZ(numHits, 0.);
 
  std::vector<float> sihit_endPosX(numHits, 0);
  std::vector<float> sihit_endPosY(numHits, 0);
  std::vector<float> sihit_endPosZ(numHits, 0);
 
  int hitNumber{0};
  const InDetDD::SiDetectorElement* de{prd->detectorElement()};
  if (de) {
    // ITk split sensors: hitLocalToLocal3D is an axis permutation without
    // translation, so the along-strip coordinate comes out in the mother frame.
    // Subtract the child's row shift to land in the child (cluster) frame.
    // StripBoxDesign keeps that shift as a translation along the design's
    // local x, which is the strip direction (it calls it zShift because the
    // strips run along global z in the barrel); in the {xPhi, xEta, xDepth}
    // frame returned by hitLocalToLocal3D it acts on xEta. StripGmxInterface
    // signs the shift per side, but the mother eta direction is the same on
    // both sides, so undo the sign on side 1.
    double alongStripShift = 0.;
    if (const auto* d = dynamic_cast<const InDetDD::SCT_ModuleSideDesign*>(&de->design())) {
      if (d->getMother()) {
        alongStripShift = d->moduleShift().translation().x();
        if (m_SCTHelper->side(prd->identify()) != 0) alongStripShift = -alongStripShift;
      }
    }
    for (const SiHit& sihit : matchingHits) {
      sihit_energyDeposit[hitNumber] = sihit.energyLoss();
      sihit_meanTime[hitNumber] = sihit.meanTime();
      sihit_uniqueID[hitNumber] = HepMC::uniqueID(sihit.particleLink());
 
      // hitLocalToLocal3D respects each design's axes (Run-3 SCT and ITk strips
      // order the SiHit components differently) and returns {xPhi, xEta, xDepth}.
      const HepGeom::Point3D<double> s{de->hitLocalToLocal3D(sihit.localStartPosition())};
      sihit_startPosX[hitNumber] = s.x();
      sihit_startPosY[hitNumber] = s.y() - alongStripShift;  // xEta, along the strip
      sihit_startPosZ[hitNumber] = s.z();
 
      const HepGeom::Point3D<double> e{de->hitLocalToLocal3D(sihit.localEndPosition())};
      sihit_endPosX[hitNumber] = e.x();
      sihit_endPosY[hitNumber] = e.y() - alongStripShift;
      sihit_endPosZ[hitNumber] = e.z();
      ++hitNumber;
    }
  }
 
  AUXDATA(xprd, std::vector<float>, sihit_energyDeposit) = std::move(sihit_energyDeposit);
  AUXDATA(xprd, std::vector<float>, sihit_meanTime) = std::move(sihit_meanTime);
  AUXDATA(xprd, std::vector<int>, sihit_barcode) = std::move(sihit_uniqueID); // TODO rename variable to be consistent?
  
  AUXDATA(xprd, std::vector<float>, sihit_startPosX) = std::move(sihit_startPosX);
  AUXDATA(xprd, std::vector<float>, sihit_startPosY) = std::move(sihit_startPosY);
  AUXDATA(xprd, std::vector<float>, sihit_startPosZ) = std::move(sihit_startPosZ);
 
  AUXDATA(xprd, std::vector<float>, sihit_endPosX) = std::move(sihit_endPosX);
  AUXDATA(xprd, std::vector<float>, sihit_endPosY) = std::move(sihit_endPosY);
  AUXDATA(xprd, std::vector<float>, sihit_endPosZ) = std::move(sihit_endPosZ);
}

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 SCT_PrepDataToxAOD::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 71 of file SCT_PrepDataToxAOD.cxx.

{
  // the cluster ambiguity map
  std::map<Identifier, const SCT_RDORawData*> idToRAWDataMap;
  if (m_writeRDOinformation) {
    SG::ReadHandle<SCT_RDO_Container> rdoContainer{m_rdoContainer, ctx};
    if (rdoContainer.isValid()) {
      // get all the RIO_Collections in the container
      for (const auto collection: *rdoContainer) {
        //get all the RDOs in the collection
        for (const auto rdo : *collection) {
          if (rdo==nullptr) {
            ATH_MSG_WARNING("Null SCT RDO. Skipping it");
            continue;
          }
          Identifier rdoId{rdo->identify()};
          idToRAWDataMap.insert(std::pair<Identifier, const SCT_RDORawData*>{rdoId, rdo});
        } // collection
      } // Have container;
    } else if (m_firstEventWarnings) {
      ATH_MSG_WARNING("Failed to retrieve SCT RDO container");
    }
  }
  ATH_MSG_DEBUG("Size of RDO map is " << idToRAWDataMap.size());
 
  const PRD_MultiTruthCollection* prdmtColl{nullptr};
  const xAODTruthParticleLinkVector *truth_particle_links{nullptr};
  if (m_useTruthInfo) {
    SG::ReadHandle<PRD_MultiTruthCollection> prdmtCollHandle{m_multiTruth, ctx};
    if (prdmtCollHandle.isValid()) {
      prdmtColl = &*prdmtCollHandle;
    }
    if (!m_truthParticleLinks.empty()) {
       SG::ReadHandle<xAODTruthParticleLinkVector> truthParticleLinksHandle{m_truthParticleLinks, ctx};
       if (truthParticleLinksHandle.isValid()) {
          truth_particle_links = truthParticleLinksHandle.cptr();
       }
    }
  }
 
  const InDetSimDataCollection* sdoCollection{nullptr};
  if (m_writeSDOs) {
    SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{m_SDOcontainer, ctx};
    if (sdoCollectionHandle.isValid()) {
      sdoCollection = &*sdoCollectionHandle;
    }
  }
 
  std::vector<std::vector<const SiHit*>> siHits(m_SCTHelper->wafer_hash_max());
  if (m_writeSiHits) {
    SG::ReadHandle<SiHitCollection> sihitCollection{m_sihitContainer, ctx};
    // ITk split sensors: a SiHit carries the mother sensor's eta_module while
    // the cluster lives on a child-row wafer (eta_module = mother + row), so
    // route each hit to its child wafer hash as StripDigitizationTool does.
    // Unsplit sensors have no mother and are unaffected. Without the element
    // collection the hits stay on the mother wafer.
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEleHandle{m_SCTDetEleCollKey, ctx};
    const InDetDD::SiDetectorElementCollection* sctElements =
        sctDetEleHandle.isValid() ? sctDetEleHandle.cptr() : nullptr;
    if (sihitCollection.isValid()) {
      for (const SiHit& siHit: *sihitCollection) {
        // Check if it is an SCT hit
        if (not siHit.isSCT()) continue;
 
        Identifier wafer_id{m_SCTHelper->wafer_id(siHit.getBarrelEndcap(),
                                                  siHit.getLayerDisk(),
                                                  siHit.getPhiModule(),
                                                  siHit.getEtaModule(),
                                                  siHit.getSide())};
        IdentifierHash wafer_hash{m_SCTHelper->wafer_hash(wafer_id)};
 
        if (sctElements) {
          const InDetDD::SiDetectorElement* baseEl = sctElements->getDetectorElement(wafer_hash);
          if (baseEl) {
            const auto* design =
                dynamic_cast<const InDetDD::SCT_ModuleSideDesign*>(&baseEl->design());
            const InDetDD::SCT_ModuleSideDesign* mother = design ? design->getMother() : nullptr;
            if (mother) {
              HepGeom::Point3D<double> avg{siHit.localStartPosition() + siHit.localEndPosition()};
              avg *= 0.5;
              // {xPhi, xEta, xDepth}; the mother-design row is the child eta offset.
              const HepGeom::Point3D<double> p3{baseEl->hitLocalToLocal3D(avg)};
              const InDetDD::SiLocalPosition slp(p3.y(), p3.x()); // (xEta along, xPhi across)
              const InDetDD::SiCellId mDiode = mother->cellIdOfPosition(slp);
              if (mDiode.isValid()) {
                const int rowOffset = mother->getStripRow(mDiode).second;
                if (rowOffset != 0) {
                  const Identifier child_id{m_SCTHelper->wafer_id(siHit.getBarrelEndcap(),
                                                                  siHit.getLayerDisk(),
                                                                  siHit.getPhiModule(),
                                                                  siHit.getEtaModule() + rowOffset,
                                                                  siHit.getSide())};
                  wafer_hash = m_SCTHelper->wafer_hash(child_id);
                }
              }
            }
          }
        }
 
        if (wafer_hash < siHits.size()) {
          siHits[wafer_hash].push_back(&siHit);
        } else {
          ATH_MSG_WARNING("SiHit routed to an unknown SCT wafer (eta_module "
                          << siHit.getEtaModule() << ", hash " << wafer_hash << "), dropped");
        }
      }
    }
  }
  
  // Mandatory. This is needed and required if this algorithm is scheduled.
  SG::ReadHandle<InDet::SCT_ClusterContainer> sctClusterContainer{m_clustercontainer, ctx};
  if (not sctClusterContainer.isValid()) {
    ATH_MSG_FATAL("Cannot retrieve SCT PrepDataContainer " << m_clustercontainer.key());
    return StatusCode::FAILURE;
  }
 
  // Create the xAOD container and its auxiliary store:
  SG::WriteHandle<xAOD::TrackMeasurementValidationContainer> xaod{m_xAodContainer, ctx};
  ATH_CHECK(xaod.record(std::make_unique<xAOD::TrackMeasurementValidationContainer>(),
                        std::make_unique<xAOD::TrackMeasurementValidationAuxContainer>()));
  
  SG::WriteHandle<std::vector<unsigned int>> offsets{m_xAodOffset, ctx};
  ATH_CHECK(offsets.record(std::make_unique<std::vector<unsigned int>>(m_SCTHelper->wafer_hash_max(), 0)));
 
  unsigned int have_truth_link=0u;
  unsigned int missing_truth_particle=0u;
  unsigned int missing_parent_particle=0u;
  // Loop over the container
  unsigned int counter{0};
  for (const auto clusterCollection: *sctClusterContainer) {
    //Fill Offset container
    (*offsets)[clusterCollection->identifyHash()] = counter;
    
    // skip empty collections
    if (clusterCollection->empty()) continue;
 
    xaod->resize(counter + clusterCollection->size());
    // loop over collection and convert to xAOD
    for (const InDet::SCT_Cluster* prd: *clusterCollection) {
      Identifier clusterId{prd->identify()};
      if (not clusterId.is_valid()) {
        ATH_MSG_WARNING("SCT cluster identifier is not valid!");
      }
 
      // create and add xAOD object
      xAOD::TrackMeasurementValidation* xprd{new xAOD::TrackMeasurementValidation()};
      xaod->at(counter) = xprd;
      ++counter;
 
      //Set Identifier
      xprd->setIdentifier(clusterId.get_compact());
 
      //Set Global Position
      Amg::Vector3D gpos{prd->globalPosition()};
      xprd->setGlobalPosition(gpos.x(), gpos.y(), gpos.z());
 
      //Set Local Position
      const Amg::Vector2D& locpos{prd->localPosition()};
      float locY{0.};
      float locX{static_cast<float>(locpos.x())};
      if ((not std::isinf(locpos.y()) or std::isnan(locpos.y()))) {
        if (locpos.y()>=1e-07) locY = locpos.y();
      } else { 
        locY = -9999.;
      }
 
      // Set local error matrix
      xprd->setLocalPosition(locX, locY);
 
      const Amg::MatrixX& localCov{prd->localCovariance()};
      if (localCov.size() == 1) {
        xprd->setLocalPositionError(localCov(0, 0), 0., 0.);
      } else if (localCov.size() == 4) {
        xprd->setLocalPositionError(localCov(0, 0), localCov(1, 1), localCov(0, 1));
      } else {
        xprd->setLocalPositionError(0., 0., 0.);
      }
         
      // Set vector of hit identifiers
      std::vector<uint64_t> rdoIdentifierList;
      rdoIdentifierList.reserve(prd->rdoList().size());
      for (const auto& hitIdentifier: prd->rdoList()) {
        rdoIdentifierList.push_back(hitIdentifier.get_compact());
      }
      xprd->setRdoIdentifierList(rdoIdentifierList);
 
      //Add SCT specific information
      const InDet::SiWidth cw{prd->width()};
      AUXDATA(xprd, int, SiWidth) = static_cast<int>(cw.colRow()[0]);
      AUXDATA(xprd, int, hitsInThirdTimeBin) = static_cast<int>(prd->hitsInThirdTimeBin());
 
      AUXDATA(xprd, int, bec)        = m_SCTHelper->barrel_ec(clusterId);
      AUXDATA(xprd, int, layer)      = m_SCTHelper->layer_disk(clusterId);
      AUXDATA(xprd, int, phi_module) = m_SCTHelper->phi_module(clusterId);
      AUXDATA(xprd, int, eta_module) = m_SCTHelper->eta_module(clusterId);
      AUXDATA(xprd, int, side)       = m_SCTHelper->side(clusterId);
   
      // Add the Detector element ID  --  not sure if needed as we have the informations above
      const InDetDD::SiDetectorElement* de{prd->detectorElement()};
 
      uint64_t detElementId{0};
      if (de) {
        Identifier detId{de->identify()};
        if (detId.is_valid()) {
          detElementId = detId.get_compact();
        }
      }
      AUXDATA(xprd, uint64_t, detectorElementID) = detElementId;
   
      //Add details about the individual hits 
      if (m_writeRDOinformation) {
        addRDOInformation(xprd, prd, idToRAWDataMap);
      }
      
      // Use the MultiTruth Collection to get a list of all true particle contributing to the cluster
      if (m_useTruthInfo) {
        if (prdmtColl) {
          auto range{prdmtColl->equal_range(clusterId)};
          if (truth_particle_links) {
             std::vector<unsigned int> tp_indices;
             for (auto i{range.first}; i!=range.second; ++i) {
                ElementLink<xAOD::TruthParticleContainer> a_truth_particle_link = truth_particle_links->find(i->second);
                if (a_truth_particle_link) {
                   const xAOD::TruthParticle *truth_particle = *a_truth_particle_link;
                   if (truth_particle) {
                      ++have_truth_link;
                      tp_indices.push_back(static_cast<int>(truth_particle->index()));
                   }
                   else {
                      ++missing_parent_particle;
                   }
                }
                else {
                   tp_indices.push_back(std::numeric_limits<unsigned int>::max());
                   ++missing_truth_particle;
                }
             }
             AUXDATA(xprd, std::vector<unsigned int>, truth_index) = std::move(tp_indices);
          }
          std::vector<int> uniqueIDs;
          for (auto& i{range.first}; i!=range.second; ++i) {
            uniqueIDs.push_back(HepMC::uniqueID(i->second));
          }
          AUXDATA(xprd, std::vector<int>, truth_barcode) = std::move(uniqueIDs); // TODO rename variable to be consistent?
        }
      }
 
      // Use the SDO Collection to get a list of all true particle contributing to the cluster per readout element
      //  Also get the energy deposited by each true particle per readout element   
      std::vector<std::vector<int>> sdoTruthUIDs;
      if (m_writeSDOs) {
        if (sdoCollection) {
          sdoTruthUIDs = addSDOInformation(xprd, prd, sdoCollection);
        }
      }
    
      // Now Get the most detailed truth from the SiHits
      // Note that this could get really slow if there are a lot of hits and clusters
      if (m_writeSiHits) {
        addSiHitInformation(xprd, prd, &siHits[prd->detectorElement()->identifyHash()], sdoTruthUIDs);
      }
    }
  }
  ATH_MSG_DEBUG(" recorded SCT_PrepData objects: size " << xaod->size());
 
  m_haveTruthLink += have_truth_link;
  m_missingTruthParticle += missing_truth_particle;
  m_missingParentParticle += missing_parent_particle;
  m_firstEventWarnings = false; //disable one-time warnings
 
  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 & AthCommonAlgorithm< 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 89 of file AthCommonAlgorithm.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 AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

finalize()

StatusCode SCT_PrepDataToxAOD::finalize ( )

overridevirtual

Definition at line 604 of file SCT_PrepDataToxAOD.cxx.

{
   if (m_useTruthInfo && !m_truthParticleLinks.empty()) {
      ATH_MSG_INFO("Missing truth particles " << m_missingTruthParticle << " missing parent: " << m_missingParentParticle
                    << " have " << m_haveTruthLink);
   }
  return StatusCode::SUCCESS;
}

findAllHitsCompatibleWithCluster()

void SCT_PrepDataToxAOD::findAllHitsCompatibleWithCluster ( const InDet::SCT_Cluster * prd, const std::vector< const SiHit * > * siHits, const std::vector< std::vector< int > > & sdoTruthUIDs, std::vector< SiHit > & matchingHits ) const

private

Definition at line 449 of file SCT_PrepDataToxAOD.cxx.

{
  ATH_MSG_VERBOSE("Got " << siHits->size() << " SiHits to look through");
 
  // Check if we have detector element  --  needed to find the local position of the SiHits
  const InDetDD::SiDetectorElement* de{prd->detectorElement()};
  if (de==nullptr) return;
 
  std::vector<const SiHit*> multiMatchingHits;
 
  for (const SiHit* siHit: *siHits) {
    // Match by geometry (SiHit centroid within +/-1 strip of a cluster RDO) or,
    // failing that, by the SiHit's truth particle having deposited charge in one
    // of the cluster's RDOs. Charge sharing and steep angles on ITk strips push
    // the centroid several strips away from the fired strips.
    bool matched = false;
    if (m_useSiHitsGeometryMatching) {
      HepGeom::Point3D<double> averagePosition{siHit->localStartPosition() + siHit->localEndPosition()};
      averagePosition *= 0.5;
      const HepGeom::Point3D<double> p3{de->hitLocalToLocal3D(averagePosition)};
      const Amg::Vector2D pos{p3.x(), p3.y()}; // (xPhi across, xEta along)
      InDetDD::SiCellId diode{de->cellIdOfPosition(pos)};
 
      for (const auto& hitIdentifier: prd->rdoList()) {
        ATH_MSG_DEBUG("Truth Strip " <<  diode.phiIndex() << " Cluster Strip " << m_SCTHelper->strip(hitIdentifier));
 
        if (std::abs(static_cast<int>(diode.phiIndex()) - m_SCTHelper->strip(hitIdentifier))<=1) {
          multiMatchingHits.push_back(siHit);
          matched = true;
          break;
        }
      }
    }
    if (!matched) {
      const auto uid = HepMC::uniqueID(siHit->particleLink());
      for (const auto& uniqueIDSDOColl: sdoTruthUIDs) {
        if (std::find(uniqueIDSDOColl.begin(), uniqueIDSDOColl.end(), uid) == uniqueIDSDOColl.end()) continue;
        multiMatchingHits.push_back(siHit);
        break;
      }
    }
  }
 
  matchingHits.reserve(multiMatchingHits.size());
  //Now we will now make 1 SiHit for each true particle if the SiHits "touch" other 
  std::vector<const SiHit*>::iterator siHitIter{multiMatchingHits.begin()};
  std::vector<const SiHit*>::iterator siHitIter2{multiMatchingHits.begin()};
  ATH_MSG_DEBUG("Found " << multiMatchingHits.size() << " SiHit ");
  for (; siHitIter != multiMatchingHits.end(); ++siHitIter) {
    const SiHit* lowestXPos{*siHitIter};
    const SiHit* highestXPos{*siHitIter};
 
    // We will merge these hits
    std::vector<const SiHit*> ajoiningHits;
    ajoiningHits.push_back(*siHitIter);
  
    siHitIter2 = siHitIter+1;
    auto uniqueID = HepMC::uniqueID((*siHitIter)->particleLink());
    while (siHitIter2 != multiMatchingHits.end()) {
      // Need to come from the same truth particle
      if ( uniqueID != HepMC::uniqueID((*siHitIter2)->particleLink())) {
        ++siHitIter2;
        continue;
      }
 
      constexpr double maxDiff = 0.00005;
      // Check to see if the SiHits are compatible with each other.
      if (std::abs((highestXPos->localEndPosition().x()-(*siHitIter2)->localStartPosition().x()))<maxDiff and
          std::abs((highestXPos->localEndPosition().y()-(*siHitIter2)->localStartPosition().y()))<maxDiff and
          std::abs((highestXPos->localEndPosition().z()-(*siHitIter2)->localStartPosition().z()))<maxDiff) {
        highestXPos = *siHitIter2;
        ajoiningHits.push_back(*siHitIter2);
        // Dont use hit  more than once
        siHitIter2 = multiMatchingHits.erase(siHitIter2);
      } else if (std::abs((lowestXPos->localStartPosition().x()-(*siHitIter2)->localEndPosition().x()))<maxDiff and
                 std::abs((lowestXPos->localStartPosition().y()-(*siHitIter2)->localEndPosition().y()))<maxDiff and
                 std::abs((lowestXPos->localStartPosition().z()-(*siHitIter2)->localEndPosition().z()))<maxDiff) {
        lowestXPos = *siHitIter2;
        ajoiningHits.push_back(*siHitIter2);
        // Dont use hit  more than once
        siHitIter2 = multiMatchingHits.erase(siHitIter2);
      } else {
        ++siHitIter2;
      }
    }
    
    if (ajoiningHits.size()==0) {
      ATH_MSG_ERROR("This should really never happen");
      continue;
    } else if (ajoiningHits.size()==1) {
      // Copy Si Hit ready to return
      matchingHits.emplace_back(*ajoiningHits[0]);
      continue;
    } else {
      //  Build new SiHit and merge information together.
      ATH_MSG_DEBUG("Merging " << ajoiningHits.size() << " SiHits together.");
      float energyDep{0.};
      float time{0.};
      for (auto& siHit: ajoiningHits) {
        energyDep += siHit->energyLoss();
        time += siHit->meanTime();
      }
      time /= static_cast<float>(ajoiningHits.size());
      matchingHits.emplace_back(lowestXPos->localStartPosition(), 
                                highestXPos->localEndPosition(),
                                energyDep,
                                time,
                                (*siHitIter)->particleLink(),
                                1, // 0 for pixel 1 for SCT
                                (*siHitIter)->getBarrelEndcap(),
                                (*siHitIter)->getLayerDisk(),
                                (*siHitIter)->getEtaModule(),
                                (*siHitIter)->getPhiModule(),
                                (*siHitIter)->getSide());
    }
  }
}

initialize()

StatusCode SCT_PrepDataToxAOD::initialize ( )

overridevirtual

Definition at line 42 of file SCT_PrepDataToxAOD.cxx.

{
  ATH_CHECK(detStore()->retrieve(m_SCTHelper, "SCT_ID"));
 
  //make sure we don't write what we don't have
  if (not m_useTruthInfo) {
    m_writeSDOs.set(false);
    m_writeSiHits.set(false);
  }
 
  ATH_CHECK(m_clustercontainer.initialize());
  ATH_CHECK(m_SDOcontainer.initialize(m_writeSDOs));
  ATH_CHECK(m_sihitContainer.initialize(m_writeSiHits));
  ATH_CHECK(m_multiTruth.initialize(m_useTruthInfo));
  ATH_CHECK(m_rdoContainer.initialize(m_writeRDOinformation));
  ATH_CHECK(m_xAodContainer.initialize());
  ATH_CHECK(m_xAodOffset.initialize());
  ATH_CHECK(m_truthParticleLinks.initialize( m_useTruthInfo && !m_truthParticleLinks.empty()));
 
  ATH_CHECK(m_SCTDetEleCollKey.initialize());
 
  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()

virtual bool SCT_PrepDataToxAOD::isClonable ( ) const

inlineoverridevirtual

Make this algorithm clonable.

Reimplemented from AthCommonAlgorithm< Gaudi::Algorithm >.

Definition at line 55 of file SCT_PrepDataToxAOD.h.

{ 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 AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

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

sysExecute()

StatusCode AthCommonAlgorithm< 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.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< 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 AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.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_clustercontainer

SG::ReadHandleKey<InDet::SCT_ClusterContainer> SCT_PrepDataToxAOD::m_clustercontainer {this, "SiClusterContainer", "SCT_Clusters"}

private

Definition at line 82 of file SCT_PrepDataToxAOD.h.

{this, "SiClusterContainer", "SCT_Clusters"};

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 AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_firstEventWarnings

std::atomic_bool SCT_PrepDataToxAOD::m_firstEventWarnings {false}

mutableprivate

Definition at line 108 of file SCT_PrepDataToxAOD.h.

{false};

m_haveTruthLink

std::atomic<unsigned int> SCT_PrepDataToxAOD::m_haveTruthLink {}

mutableprivate

Definition at line 105 of file SCT_PrepDataToxAOD.h.

{};

m_missingParentParticle

std::atomic<unsigned int> SCT_PrepDataToxAOD::m_missingParentParticle {}

mutableprivate

Definition at line 107 of file SCT_PrepDataToxAOD.h.

{};

m_missingTruthParticle

std::atomic<unsigned int> SCT_PrepDataToxAOD::m_missingTruthParticle {}

mutableprivate

Definition at line 106 of file SCT_PrepDataToxAOD.h.

{};

m_multiTruth

SG::ReadHandleKey<PRD_MultiTruthCollection> SCT_PrepDataToxAOD::m_multiTruth {this, "PRD_MultiTruth", "PRD_MultiTruthSCT"}

private

Definition at line 85 of file SCT_PrepDataToxAOD.h.

{this, "PRD_MultiTruth", "PRD_MultiTruthSCT"};

m_rdoContainer

SG::ReadHandleKey<SCT_RDO_Container> SCT_PrepDataToxAOD::m_rdoContainer {this, "SctRdoContainer", "SCT_RDOs"}

private

Definition at line 89 of file SCT_PrepDataToxAOD.h.

{this, "SctRdoContainer", "SCT_RDOs"};

m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> SCT_PrepDataToxAOD::m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}

private

Definition at line 94 of file SCT_PrepDataToxAOD.h.

{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};

m_SCTHelper

const SCT_ID* SCT_PrepDataToxAOD::m_SCTHelper {nullptr}

private

Definition at line 81 of file SCT_PrepDataToxAOD.h.

{nullptr};

m_SDOcontainer

SG::ReadHandleKey<InDetSimDataCollection> SCT_PrepDataToxAOD::m_SDOcontainer {this, "MC_SDOs", "SCT_SDO_Map"}

private

Definition at line 83 of file SCT_PrepDataToxAOD.h.

{this, "MC_SDOs", "SCT_SDO_Map"};

m_sihitContainer

SG::ReadHandleKey<SiHitCollection> SCT_PrepDataToxAOD::m_sihitContainer {this, "MC_Hits", "SCT_Hits"}

private

Definition at line 84 of file SCT_PrepDataToxAOD.h.

{this, "MC_Hits", "SCT_Hits"};

m_truthParticleLinks

SG::ReadHandleKey<xAODTruthParticleLinkVector> SCT_PrepDataToxAOD::m_truthParticleLinks {this,"InputTruthParticleLinks","","The key for the truth particle link collection."}

private

Definition at line 86 of file SCT_PrepDataToxAOD.h.

{this,"InputTruthParticleLinks","","The key for the truth particle link collection."};

m_useSiHitsGeometryMatching

BooleanProperty SCT_PrepDataToxAOD::m_useSiHitsGeometryMatching

private

Initial value:

{this, "UseSiHitsGeometryMatching", true,
    "match SiHits to clusters by geometry (+/-1 strip) in union with the SDO "
    "truth-uniqueID intersection; false = SDO intersection only"}

Definition at line 100 of file SCT_PrepDataToxAOD.h.

                                             {this, "UseSiHitsGeometryMatching", true,
    "match SiHits to clusters by geometry (+/-1 strip) in union with the SDO "
    "truth-uniqueID intersection; false = SDO intersection only"};

m_useTruthInfo

BooleanProperty SCT_PrepDataToxAOD::m_useTruthInfo {this, "UseTruthInfo", false}

private

Definition at line 96 of file SCT_PrepDataToxAOD.h.

{this, "UseTruthInfo", false};

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.

m_writeRDOinformation

BooleanProperty SCT_PrepDataToxAOD::m_writeRDOinformation {this, "WriteRDOinformation", true}

private

Definition at line 97 of file SCT_PrepDataToxAOD.h.

{this, "WriteRDOinformation", true};

m_writeSDOs

BooleanProperty SCT_PrepDataToxAOD::m_writeSDOs {this, "WriteSDOs", false}

private

Definition at line 98 of file SCT_PrepDataToxAOD.h.

{this, "WriteSDOs", false};

m_writeSiHits

BooleanProperty SCT_PrepDataToxAOD::m_writeSiHits {this, "WriteSiHits", false}

private

Definition at line 99 of file SCT_PrepDataToxAOD.h.

{this, "WriteSiHits", false};

m_xAodContainer

SG::WriteHandleKey<xAOD::TrackMeasurementValidationContainer> SCT_PrepDataToxAOD::m_xAodContainer {this, "SctxAodContainer", "SCT_Clusters"}

private

Definition at line 90 of file SCT_PrepDataToxAOD.h.

{this, "SctxAodContainer", "SCT_Clusters"};

m_xAodOffset

SG::WriteHandleKey<std::vector<unsigned int> > SCT_PrepDataToxAOD::m_xAodOffset {this, "SctxAodOffset", "SCT_ClustersOffsets"}

private

Definition at line 91 of file SCT_PrepDataToxAOD.h.

{this, "SctxAodOffset", "SCT_ClustersOffsets"};

---

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

• SCT_PrepDataToxAOD.h
• SCT_PrepDataToxAOD.cxx