Muon::sTgcRdoToPrepDataToolMT Class Reference

#include <sTgcRdoToPrepDataToolMT.h>

Inheritance diagram for Muon::sTgcRdoToPrepDataToolMT:

Classes
struct	DataCache
	Data cache to hold the translated prd & xAOD containers. More...

Public Member Functions
virtual	~sTgcRdoToPrepDataToolMT ()=default
	Destructor.
virtual StatusCode	initialize () override
	Standard AthAlgTool initialize method.
StatusCode	decode (const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override
	Decode RDO to PRD A vector of IdentifierHash are passed in, and the data corresponding to this list (i.e.
StatusCode	decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override
StatusCode	provideEmptyContainer (const EventContext &ctx) const override

Protected Types
using	PrdKey_t = SG::WriteHandleKey<sTgcPrepDataContainer>

Protected Member Functions
StatusCode	processCollection (const EventContext &ctx, DataCache &xAODcontainers, const STGC_RawDataCollection *rdoColl) const
DataCache	setupOutputContainers (const EventContext &ctx) const
const STGC_RawDataContainer *	getRdoContainer (const EventContext &ctx) const
void	processRDOContainer (const EventContext &ctx, DataCache &xAODcontainers, const std::vector< IdentifierHash > &idsToDecode) const

Protected Attributes
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}
ServiceHandle< IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadHandleKey< STGC_RawDataContainer >	m_rdoContainerKey {this, "InputCollection", "sTGCRDO", "RDO container to read"}
PrdKey_t	m_stgcPrepDataContainerKey {this, "OutputCollection", "STGC_Measurements", "sTgcPrepDataContainer to record"}
Gaudi::Property< bool >	m_merge {this, "Merge", true}
ToolHandle< ISTgcClusterBuilderTool >	m_clusterBuilderTool {this,"ClusterBuilderTool","SimpleSTgcClusterBuilderTool/SimpleSTgcClusterBuilderTool"}
ToolHandle< INSWCalibTool >	m_calibTool {this,"NSWCalibTool", ""}
SG::UpdateHandleKey< sTgcPrepDataCollection_Cache >	m_prdContainerCacheKey {this, "PrdCacheKey", "", "Optional external cache for the sTGC PRD container"}
	This is the key for the cache for the sTGC PRD containers, can be empty.
SG::WriteHandleKey< xAOD::sTgcStripContainer >	m_xAODStripKey {this, "xAODStripKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}
SG::WriteHandleKey< xAOD::sTgcPadContainer >	m_xAODPadKey {this, "xAODPadKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}
SG::WriteHandleKey< xAOD::sTgcWireContainer >	m_xAODWireKey {this, "xAODWireKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}
Gaudi::Property< bool >	m_useNewGeo
const MuonGMR4::MuonDetectorManager *	m_detMgrR4 {nullptr}

Detailed Description

Definition at line 39 of file sTgcRdoToPrepDataToolMT.h.

Member Typedef Documentation

PrdKey_t

using Muon::sTgcRdoToPrepDataToolMT::PrdKey_t = SG::WriteHandleKey<sTgcPrepDataContainer>

protected

Definition at line 62 of file sTgcRdoToPrepDataToolMT.h.

Constructor & Destructor Documentation

~sTgcRdoToPrepDataToolMT()

virtual Muon::sTgcRdoToPrepDataToolMT::~sTgcRdoToPrepDataToolMT ( )

virtualdefault

Destructor.

Member Function Documentation

decode() [1/2]

StatusCode Muon::sTgcRdoToPrepDataToolMT::decode ( const EventContext & ctx, const std::vector< IdentifierHash > & idVect ) const

override

Decode RDO to PRD
A vector of IdentifierHash are passed in, and the data corresponding to this list (i.e.

in a Region of Interest) are converted.

Parameters

requestedIdHashVect

Vector of hashes to convert i.e. the hashes of ROD collections in a 'Region of Interest'

Returns

selectedIdHashVect This is the subset of requestedIdVect which were actually found to contain data
(i.e. if you want you can use this vector of hashes to optimise the retrieval of data in subsequent steps.)

Definition at line 372 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                                                {
    ATH_MSG_DEBUG("Size of the input hash id vector: " << idVect.size());
 
    DataCache outCache = setupOutputContainers(ctx);
    if (!outCache.isValid) return StatusCode::FAILURE;
 
    processRDOContainer(ctx, outCache, idVect);
    return StatusCode::SUCCESS;
} 

decode() [2/2]

StatusCode Muon::sTgcRdoToPrepDataToolMT::decode ( const EventContext & ctx, const std::vector< uint32_t > & robIds ) const

override

Definition at line 385 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                                                 {
   ATH_MSG_FATAL("ROB based decoding is not supported....");
   return StatusCode::FAILURE;
}

getRdoContainer()

const STGC_RawDataContainer * Muon::sTgcRdoToPrepDataToolMT::getRdoContainer ( const EventContext & ctx ) const

protected

Definition at line 329 of file sTgcRdoToPrepDataToolMT.cxx.

{
    auto rdoContainerHandle  = SG::makeHandle(m_rdoContainerKey, ctx);
    if(rdoContainerHandle.isValid()) {
        ATH_MSG_DEBUG("STGC_getRdoContainer success");
        return rdoContainerHandle.cptr();  
    }
    ATH_MSG_WARNING("Retrieval of STGC_RawDataContainer failed !");
 
    return nullptr;
}

initialize()

StatusCode Muon::sTgcRdoToPrepDataToolMT::initialize ( )

overridevirtual

Standard AthAlgTool initialize method.

Definition at line 131 of file sTgcRdoToPrepDataToolMT.cxx.

{  
    ATH_MSG_DEBUG(" in initialize()");
    ATH_CHECK( m_idHelperSvc.retrieve() );
    // check if the initialization of the data container is success
    ATH_CHECK(m_stgcPrepDataContainerKey.initialize());
    ATH_CHECK(m_rdoContainerKey.initialize());
    ATH_CHECK(m_muDetMgrKey.initialize());
    ATH_CHECK(m_calibTool.retrieve());
    ATH_CHECK(m_prdContainerCacheKey.initialize(!m_prdContainerCacheKey.key().empty()) );
 
    if (m_useNewGeo) {
        ATH_CHECK(detStore()->retrieve(m_detMgrR4));
    }
 
    ATH_CHECK(m_xAODStripKey.initialize(!m_xAODStripKey.empty()));
    ATH_CHECK(m_xAODWireKey.initialize(!m_xAODWireKey.empty()));
    ATH_CHECK(m_xAODPadKey.initialize(!m_xAODPadKey.empty()));
    return StatusCode::SUCCESS;
}

processCollection()

StatusCode Muon::sTgcRdoToPrepDataToolMT::processCollection ( const EventContext & ctx, DataCache & xAODcontainers, const STGC_RawDataCollection * rdoColl ) const

protected

Definition at line 154 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                                                         {
 
    const sTgcIdHelper& id_helper = m_idHelperSvc->stgcIdHelper();
    const IdentifierHash hash = rdoColl->identifyHash();
 
    ATH_MSG_DEBUG(" ***************** Start of process STGC Collection with hash Id: " << hash);
  
    // check if the collection already exists, otherwise add it
    if ( cache.prdWriteHandle->indexFindPtr(hash) != nullptr ) {
        ATH_MSG_DEBUG("In processCollection: collection already contained in the sTGC PrepData container");
        return StatusCode::FAILURE;
 
    } 
 
    // Get write handle for this collection
    sTgcPrepDataContainer::IDC_WriteHandle lock = cache.prdWriteHandle->getWriteHandle( hash );
    // Check if collection already exists (via the cache, i.e. in online trigger mode)
    if( lock.OnlineAndPresentInAnotherView() ) {
      ATH_MSG_DEBUG("In processCollection: collection already available in the sTgc PrepData container (via cache)");
      return StatusCode::SUCCESS;
    }
 
    // Make the PRD collection (will be added to container later
    std::unique_ptr<sTgcPrepDataCollection>& prdColl = cache.collections[hash];
    if (!prdColl) {
       prdColl = std::make_unique<sTgcPrepDataCollection>(hash);
    }
 
    // set the offline identifier of the collection Id
    IdContext  context = id_helper.module_context();
    Identifier moduleId;
    int getId = id_helper.get_id(hash, moduleId, &context);
    if ( getId != 0 ) {
      ATH_MSG_ERROR("Could not convert the hash Id: " << hash << " to identifier");
    } else {
      prdColl->setIdentifier(moduleId);
    }
 
    // vectors to hold PRDs decoded for this RDO collection
    std::vector<sTgcPrepData> sTgcStripPrds;
    std::vector<sTgcPrepData> sTgcWirePrds;
    std::vector<sTgcPrepData> sTgcPadPrds;
    sTgcStripPrds.reserve(rdoColl->size());
    sTgcPadPrds.reserve(rdoColl->size());
    sTgcWirePrds.reserve(rdoColl->size());
    
    // Count hits with negative charge, which indicates bad calibration
    
  
    // MuonDetectorManager from the conditions store
    const MuonGM::MuonDetectorManager* muonDetMgr{nullptr};
    ATH_CHECK(SG::get(muonDetMgr,m_muDetMgrKey,ctx));
    // convert the RDO collection to a PRD collection
    for ( const STGC_RawData* rdo : * rdoColl) {
 
        ATH_MSG_DEBUG("Adding a new sTgc PrepRawData");
 
        const Identifier  rdoId = rdo->identify();
 
        std::vector<Identifier> rdoList{rdoId};
    
        // get the local and global positions
        const MuonGM::sTgcReadoutElement* detEl = muonDetMgr->getsTgcReadoutElement(rdoId);
        Amg::Vector2D localPos{Amg::Vector2D::Zero()};
 
        int channelType = id_helper.channelType(rdoId);
        if (channelType < 0 || channelType > 2) {
            ATH_MSG_ERROR("Unknown sTGC channel type");
            return StatusCode::FAILURE;
        }
        if (!detEl->stripPosition(rdoId, localPos)) {
            ATH_MSG_ERROR("Could not get the local strip position for "<<m_idHelperSvc->toString(rdoId));
            return StatusCode::FAILURE;
        } 
 
        // get the resolution from strip width
        // to be fixed: for now do not set the resolution, it will be added in the next update    
        const int     gasGap = id_helper.gasGap(rdoId);
        const int    channel = id_helper.channel(rdoId);
 
        NSWCalib::CalibratedStrip calibStrip;
        ATH_CHECK (m_calibTool->calibrateStrip(ctx, rdo, calibStrip));
        int calibratedCharge = static_cast<int>(calibStrip.charge);
        if (calibratedCharge < 0 && channelType == 1) { // we only want to protect against negatively charged strips and we should not lose wire or pad hits because of bad calibrations since charge does not matter for them in reco. 
            if (!hitNegativeCharge) {
                ATH_MSG_DEBUG("One sTGC RDO or more, such as one with pdo = "<<rdo->charge() << " counts, corresponds to a negative charge (" << calibratedCharge << "). Skipping these RDOs");
                hitNegativeCharge = true; 
            }
            continue;
        }
        
        double width{0.};
        if (channelType == sTgcIdHelper::sTgcChannelTypes::Pad) { // Pads
            const MuonGM::MuonPadDesign* design = detEl->getPadDesign(rdoId);
            if (!design) {
                ATH_MSG_WARNING("Failed to get design for sTGC pad" );
            } else {
                width = design->channelWidth(localPos, true);
            } 
        } else { // Strips and wires
            const MuonGM::MuonChannelDesign* design = detEl->getDesign(rdoId);
            if (!design) {
                ATH_MSG_WARNING("Failed to get design for sTGC strip/wire" );
            } else {
                width = design->channelWidth();
            }
        }
                
        const double resolution = width/ std::sqrt(12.); 
        auto   cov = Amg::MatrixX(1,1);
        cov.setIdentity();
        (cov)(0,0) = resolution*resolution;  
 
        ATH_MSG_DEBUG("Adding a new STGC PRD, gasGap: " << gasGap << " channel: " << channel << " type: " << channelType << " resolution " << resolution );
 
        if(m_merge) {
            std::vector<sTgcPrepData>& sTgcPrds = channelType == sTgcIdHelper::Pad ? sTgcPadPrds : 
                                                  (channelType == sTgcIdHelper::Strip ? sTgcStripPrds : sTgcWirePrds);
        
            // check if the same RdoId is already present; keep the one with the smallest time
            auto it = std::find_if(sTgcPrds.begin(), sTgcPrds.end(), [&rdoId](const sTgcPrepData& prd) { 
                                                                        return (prd.identify() == rdoId); 
                                                                    });
            if (it == sTgcPrds.end()) {
                sTgcPrds.emplace_back(rdoId, hash, std::move(localPos), std::move(rdoList), std::move(cov), detEl, calibratedCharge, calibStrip.time);
                sTgcPrds.back().setAuthor(sTgcPrepData::Author::RdoToPrdConverter);
            } else if (it->time() > calibStrip.time) {
                *it = sTgcPrepData(rdoId, hash, std::move(localPos), std::move(rdoList), std::move(cov), detEl, calibratedCharge, calibStrip.time);
                it->setAuthor(sTgcPrepData::Author::RdoToPrdConverter);
            }
            
            // TODO - add merging for xAOD
 
        } else {
          // if not merging just add the PRD to the collection
          prdColl->push_back(std::make_unique<sTgcPrepData>(rdoId, 
                                                            hash, 
                                                            std::move(localPos), 
                                                            std::move(rdoList),
                                                            std::move(cov), 
                                                            detEl, 
                                                            calibratedCharge, 
                                                            calibStrip.time));
        }
    }
 
    if(m_merge) {
        // merge strip prds that fire closeby channels (not clusterizing wires and pads)
        std::vector<std::unique_ptr<sTgcPrepData>> sTgcStripClusters;
        ATH_CHECK(m_clusterBuilderTool->getClusters(ctx, std::move(sTgcStripPrds), sTgcStripClusters)); // Clusterize strips
 
        for ( std::unique_ptr<sTgcPrepData>& it : sTgcStripClusters ) {
            it->setHashAndIndex(prdColl->identifyHash(), prdColl->size());
            prdColl->push_back(std::move(it));
        } 
        for ( sTgcPrepData& prd : sTgcWirePrds ) {
            prd.setHashAndIndex(prdColl->identifyHash(), prdColl->size());
            prdColl->push_back(std::make_unique<sTgcPrepData>(std::move(prd)));
        }
        for (sTgcPrepData& prd : sTgcPadPrds ) {
            prd.setHashAndIndex(prdColl->identifyHash(), prdColl->size());
            prdColl->push_back(std::make_unique<sTgcPrepData>(std::move(prd)));
        }
    }
 
    // now add the collection to the container
    ATH_MSG_DEBUG("PRD hash " << hash << " has been moved to container");
 
    return StatusCode::SUCCESS;
}

processRDOContainer()

void Muon::sTgcRdoToPrepDataToolMT::processRDOContainer ( const EventContext & ctx, DataCache & xAODcontainers, const std::vector< IdentifierHash > & idsToDecode ) const

protected

Definition at line 343 of file sTgcRdoToPrepDataToolMT.cxx.

{
    ATH_MSG_DEBUG("In processRDOContainer");
    const STGC_RawDataContainer* rdoContainer = getRdoContainer(ctx);
    if (!rdoContainer) return;
  
    // run in unseeded mode
    for (const STGC_RawDataCollection* rdoColl : *rdoContainer) {
        if (rdoColl->empty()) continue;
        ATH_MSG_DEBUG("New RDO collection with " << rdoColl->size() << "STGC Hits");
 
        const IdentifierHash hash = rdoColl->identifyHash();
 
        // check if we actually want to decode this RDO collection
        if(!idsToDecode.empty() and std::find(idsToDecode.begin(), idsToDecode.end(), hash)==idsToDecode.end()) {
            ATH_MSG_DEBUG("Hash ID " << hash << " not in input list, ignore");
            continue;
        } else ATH_MSG_DEBUG("Going to decode " << hash);
 
        if(processCollection(ctx, cache, rdoColl).isFailure()) {
            ATH_MSG_DEBUG("processCsm returns a bad StatusCode - keep going for new data collections in this event");
        }
    } 
}

provideEmptyContainer()

StatusCode Muon::sTgcRdoToPrepDataToolMT::provideEmptyContainer ( const EventContext & ctx ) const

override

Definition at line 389 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                                       {
    return setupOutputContainers(ctx).isValid ? StatusCode::SUCCESS : StatusCode::FAILURE;
}

setupOutputContainers()

sTgcRdoToPrepDataToolMT::DataCache Muon::sTgcRdoToPrepDataToolMT::setupOutputContainers ( const EventContext & ctx ) const

protected

use the cache to get the container

Definition at line 395 of file sTgcRdoToPrepDataToolMT.cxx.

                                                                              {
      
    
      const std::size_t hashMax = m_idHelperSvc->stgcIdHelper().module_hash_max();
      DataCache containers{hashMax, m_stgcPrepDataContainerKey, ctx};
 
      containers.detMgr = m_detMgrR4;
      if(m_prdContainerCacheKey.key().empty()) {
         // No external cache, just record the container
 
         if (!containers.prdWriteHandle.record(std::make_unique<sTgcPrepDataContainer>(hashMax)).isSuccess()){
             ATH_MSG_FATAL("Faile to record "<<m_stgcPrepDataContainerKey.fullKey());
             return containers; 
         }
      } else {
        SG::UpdateHandle update{m_prdContainerCacheKey, ctx};
        if (!update.isValid()) {
          ATH_MSG_FATAL("Invalid UpdateHandle " << m_prdContainerCacheKey.key());
          return containers;
        }
        if (!containers.prdWriteHandle.record(std::make_unique<sTgcPrepDataContainer>(update.ptr())).isSuccess()) {
            ATH_MSG_FATAL("Failed to record "<<m_stgcPrepDataContainerKey.fullKey()
                        <<" from "<<m_prdContainerCacheKey.fullKey());
            return containers;
        }
      }
      containers.isValid = containers.strips.record(m_xAODStripKey, ctx).isSuccess()
                         && containers.wires.record(m_xAODWireKey, ctx).isSuccess()
                         && containers.pads.record(m_xAODPadKey, ctx).isSuccess();
      return containers;
}

Member Data Documentation

m_calibTool

ToolHandle<INSWCalibTool> Muon::sTgcRdoToPrepDataToolMT::m_calibTool {this,"NSWCalibTool", ""}

protected

Definition at line 115 of file sTgcRdoToPrepDataToolMT.h.

{this,"NSWCalibTool", ""};

m_clusterBuilderTool

ToolHandle<ISTgcClusterBuilderTool> Muon::sTgcRdoToPrepDataToolMT::m_clusterBuilderTool {this,"ClusterBuilderTool","SimpleSTgcClusterBuilderTool/SimpleSTgcClusterBuilderTool"}

protected

Definition at line 114 of file sTgcRdoToPrepDataToolMT.h.

{this,"ClusterBuilderTool","SimpleSTgcClusterBuilderTool/SimpleSTgcClusterBuilderTool"};

m_detMgrR4

const MuonGMR4::MuonDetectorManager* Muon::sTgcRdoToPrepDataToolMT::m_detMgrR4 {nullptr}

protected

Definition at line 128 of file sTgcRdoToPrepDataToolMT.h.

{nullptr};

m_idHelperSvc

ServiceHandle<IMuonIdHelperSvc> Muon::sTgcRdoToPrepDataToolMT::m_idHelperSvc {this, "MuonIdHelperSvc", "MuonIdHelperSvc/MuonIdHelperSvc"}

protected

Definition at line 107 of file sTgcRdoToPrepDataToolMT.h.

{this, "MuonIdHelperSvc", "MuonIdHelperSvc/MuonIdHelperSvc"};

m_merge

Gaudi::Property<bool> Muon::sTgcRdoToPrepDataToolMT::m_merge {this, "Merge", true}

protected

Definition at line 112 of file sTgcRdoToPrepDataToolMT.h.

{this, "Merge", true}; // merge Prds

m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::sTgcRdoToPrepDataToolMT::m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}

protected

Definition at line 105 of file sTgcRdoToPrepDataToolMT.h.

{this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}; 

m_prdContainerCacheKey

SG::UpdateHandleKey<sTgcPrepDataCollection_Cache> Muon::sTgcRdoToPrepDataToolMT::m_prdContainerCacheKey {this, "PrdCacheKey", "", "Optional external cache for the sTGC PRD container"}

protected

This is the key for the cache for the sTGC PRD containers, can be empty.

Definition at line 118 of file sTgcRdoToPrepDataToolMT.h.

{this, "PrdCacheKey", "", "Optional external cache for the sTGC PRD container"};

m_rdoContainerKey

SG::ReadHandleKey<STGC_RawDataContainer> Muon::sTgcRdoToPrepDataToolMT::m_rdoContainerKey {this, "InputCollection", "sTGCRDO", "RDO container to read"}

protected

Definition at line 110 of file sTgcRdoToPrepDataToolMT.h.

{this, "InputCollection", "sTGCRDO", "RDO container to read"};

m_stgcPrepDataContainerKey

PrdKey_t Muon::sTgcRdoToPrepDataToolMT::m_stgcPrepDataContainerKey {this, "OutputCollection", "STGC_Measurements", "sTgcPrepDataContainer to record"}

protected

Definition at line 111 of file sTgcRdoToPrepDataToolMT.h.

{this, "OutputCollection", "STGC_Measurements", "sTgcPrepDataContainer to record"};

m_useNewGeo

Gaudi::Property<bool> Muon::sTgcRdoToPrepDataToolMT::m_useNewGeo

protected

Initial value:

{this, "UseR4DetMgr", false,
                                         "Switch between the legacy and the new geometry"}

Definition at line 125 of file sTgcRdoToPrepDataToolMT.h.

                                     {this, "UseR4DetMgr", false,
                                         "Switch between the legacy and the new geometry"};

m_xAODPadKey

SG::WriteHandleKey<xAOD::sTgcPadContainer> Muon::sTgcRdoToPrepDataToolMT::m_xAODPadKey {this, "xAODPadKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

protected

Definition at line 122 of file sTgcRdoToPrepDataToolMT.h.

{this, "xAODPadKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"};

m_xAODStripKey

SG::WriteHandleKey<xAOD::sTgcStripContainer> Muon::sTgcRdoToPrepDataToolMT::m_xAODStripKey {this, "xAODStripKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

protected

Definition at line 121 of file sTgcRdoToPrepDataToolMT.h.

{this, "xAODStripKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"};

m_xAODWireKey

SG::WriteHandleKey<xAOD::sTgcWireContainer> Muon::sTgcRdoToPrepDataToolMT::m_xAODWireKey {this, "xAODWireKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

protected

Definition at line 123 of file sTgcRdoToPrepDataToolMT.h.

{this, "xAODWireKey", "", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"};

---

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

• sTgcRdoToPrepDataToolMT.h
• sTgcRdoToPrepDataToolMT.cxx