Muon::STGC_ROD_Decoder Class Reference

#include <STGC_ROD_Decoder.h>

Inheritance diagram for Muon::STGC_ROD_Decoder:

Collaboration diagram for Muon::STGC_ROD_Decoder:

Public Member Functions
virtual	~STGC_ROD_Decoder ()=default
virtual StatusCode	initialize () override
virtual StatusCode	fillCollection (const EventContext &ctx, const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &fragment, const std::vector< IdentifierHash > &chamberToDecode, std::vector< std::unique_ptr< STGC_RawDataCollection > > &rdo_map) const override

Protected Attributes
const sTgcIdHelper *	m_stgcIdHelper {nullptr}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey
SG::ReadCondHandleKey< NswDcsDbData >	m_dscKey
SG::ReadCondHandleKey< Nsw_CablingMap >	m_cablingKey {this, "CablingMap", "","Key of Nsw_CablingMap"}

Detailed Description

Definition at line 22 of file STGC_ROD_Decoder.h.

Constructor & Destructor Documentation

~STGC_ROD_Decoder()

virtual Muon::STGC_ROD_Decoder::~STGC_ROD_Decoder ( )

virtualdefault

Member Function Documentation

fillCollection()

StatusCode Muon::STGC_ROD_Decoder::fillCollection ( const EventContext & ctx, const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment & fragment, const std::vector< IdentifierHash > & chamberToDecode, std::vector< std::unique_ptr< STGC_RawDataCollection > > & rdo_map ) const

overridevirtual

Definition at line 42 of file STGC_ROD_Decoder.cxx.

{
 
  // check fragment for errors
  try {
    robFrag.check();
  } catch (const eformat::Issue &ex) {
    ATH_MSG_WARNING(ex.what());
    return StatusCode::SUCCESS;
  }
  
  const NswDcsDbData* dcsData{nullptr};
  ATH_CHECK(SG::get(dcsData, m_dscKey, ctx));
 
  const Nsw_CablingMap* sTgcCablingMap{nullptr};
  ATH_CHECK(SG::get(sTgcCablingMap, m_cablingKey, ctx));
 
  const MuonGM::MuonDetectorManager* muonGeoMgr{};
  ATH_CHECK(SG::get(muonGeoMgr, m_DetectorManagerKey, ctx));
 
  // if the vector of hashes is not empty, then we are in seeded mode
  bool seeded_mode(!rdoIdhVect.empty());
 
  // have the NSWCommonDecoder take care of the decoding
  Muon::nsw::NSWCommonDecoder common_decoder(robFrag);  
  const std::vector<Muon::nsw::NSWElink *>&   elinks = common_decoder.get_elinks();  
  ATH_MSG_DEBUG("Retrieved "<<elinks.size()<<" elinks");
  if (elinks.empty()) {
    return StatusCode::SUCCESS;
  }
  rdo_map.resize(m_stgcIdHelper->module_hash_max());
  // loop on elinks. for STGCs a "module" is a quadruplet
  // therefore, we need an RDO (collection) per quadruplet!
  for (auto* elink : elinks) {
 
    // skip null packets
    if (elink->isNull()) {
      continue;
    }
    // get the offline ID hash (module ctx) to be passed to the RDO 
    // also specifies the index of the RDO in the container.
    const char*  station_name = elink->elinkId()->is_large_station() ? "STL" : "STS";
    int          station_eta  = (int)elink->elinkId()->station_eta();
    unsigned int station_phi  = (unsigned int)elink->elinkId()->station_phi();
    unsigned int multi_layer  = (unsigned int)elink->elinkId()->multi_layer();
    unsigned int gas_gap      = (unsigned int)elink->elinkId()->gas_gap();
    Identifier   module_ID    = m_stgcIdHelper->elementID(station_name, station_eta, station_phi);
 
    IdentifierHash module_hashID{};
    m_stgcIdHelper->get_module_hash(module_ID, module_hashID);
    const MuonGM::sTgcReadoutElement* roElement = muonGeoMgr->getsTgcReadoutElement(module_ID);
    // if we are in ROI-seeded mode, check if this hashID is requested
    if (seeded_mode && std::ranges::find(rdoIdhVect, module_hashID) == rdoIdhVect.end()) {
      continue;
    }
    std::unique_ptr<STGC_RawDataCollection>& rdo = rdo_map[module_hashID];
    if (!rdo) rdo = std::make_unique<STGC_RawDataCollection>(module_hashID);
  
    // loop on all channels of this elink to fill the collection
    const std::vector<Muon::nsw::VMMChannel*>& channels = elink->get_channels();
    for (auto *channel : channels) {
       unsigned int channel_number = channel->channel_number();
       unsigned int channel_type   = channel->channel_type();
       if (channel_number == 0) continue; // skip disconnected vmm channels
 
       Identifier channel_ID = m_stgcIdHelper->channelID(module_ID, multi_layer, gas_gap, channel_type, channel_number); // not validating the IDs (too slow)
       if (sTgcCablingMap) {
          std::optional<Identifier> correctedChannelId = sTgcCablingMap->correctChannel(channel_ID, msgStream());
          if (!correctedChannelId) {
              ATH_MSG_DEBUG("Channel was shifted outside its connector and is therefore not decoded into and RDO");
              continue;
          }
          channel_ID = (*correctedChannelId);
       }
       bool isOuterQ1{false};
       if(std::abs(station_eta)==1 && dcsData){ // only the innermost quad is split in two hv sections, no need to check the others, also no need to check if no dcs data is loaded
          Amg::Vector2D localPos{Amg::Vector2D::Zero()};
          if (!roElement->stripPosition(channel_ID, localPos)) continue; // can also handle wires and pads
          isOuterQ1 = !(roElement->isEtaZero(channel_ID, localPos));
       }
 
       if (dcsData && !dcsData->isGood(ctx, channel_ID, isOuterQ1)) continue;
       bool timeAndChargeInCounts = true; // always true for data from detector
       rdo->push_back(std::make_unique<STGC_RawData>(channel_ID, channel->rel_bcid(), channel->tdo(), channel->pdo(), false,timeAndChargeInCounts)); // isDead = false (ok?)
    }
  }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode Muon::STGC_ROD_Decoder::initialize ( )

overridevirtual

Definition at line 26 of file STGC_ROD_Decoder.cxx.

{
  ATH_CHECK(detStore()->retrieve(m_stgcIdHelper, "STGCIDHELPER"));
  ATH_CHECK(m_DetectorManagerKey.initialize());
  ATH_CHECK(m_dscKey.initialize(!m_dscKey.empty()));
  ATH_CHECK(m_cablingKey.initialize(!m_cablingKey.empty()));
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_cablingKey

SG::ReadCondHandleKey<Nsw_CablingMap> Muon::STGC_ROD_Decoder::m_cablingKey {this, "CablingMap", "","Key of Nsw_CablingMap"}

protected

Definition at line 39 of file STGC_ROD_Decoder.h.

{this, "CablingMap", "","Key of Nsw_CablingMap"};

m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::STGC_ROD_Decoder::m_DetectorManagerKey

protected

Initial value:

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

Definition at line 34 of file STGC_ROD_Decoder.h.

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

m_dscKey

SG::ReadCondHandleKey<NswDcsDbData> Muon::STGC_ROD_Decoder::m_dscKey

protected

Initial value:

{this, "DcsKey", "NswDcsDbData",
        "Key of NswDcsDbData object containing DCS conditions data"}

Definition at line 36 of file STGC_ROD_Decoder.h.

                                              {this, "DcsKey", "NswDcsDbData",
        "Key of NswDcsDbData object containing DCS conditions data"};

m_stgcIdHelper

const sTgcIdHelper* Muon::STGC_ROD_Decoder::m_stgcIdHelper {nullptr}

protected

Definition at line 33 of file STGC_ROD_Decoder.h.

{nullptr};

---

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

• STGC_ROD_Decoder.h
• STGC_ROD_Decoder.cxx