SCT_ByteStreamErrorsTool.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef SCT_ByteStreamErrorsTool_h
#define SCT_ByteStreamErrorsTool_h

#include "AthenaBaseComps/AthAlgTool.h"
#include "SCT_ConditionsTools/ISCT_ByteStreamErrorsTool.h"
 
#include "AthenaKernel/SlotSpecificObj.h"
#include "Identifier/IdContext.h"
#include "Identifier/Identifier.h"
#include "Identifier/IdentifierHash.h"
#include "InDetByteStreamErrors/IDCInDetBSErrContainer.h"
#include "InDetConditionsSummaryService/InDetHierarchy.h"
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"

#include "GaudiKernel/EventContext.h"
#include "GaudiKernel/EventIDBase.h"

#include <array>
#include <atomic>
#include <functional>
#include <unordered_map>
#include <vector>

class SCT_ID;

 
class SCT_ByteStreamErrorsTool: public extends<AthAlgTool, ISCT_ByteStreamErrorsTool> {
 
public:
  //@name Tool methods
  SCT_ByteStreamErrorsTool(const std::string& type, const std::string& name, const IInterface* parent);
  virtual ~SCT_ByteStreamErrorsTool() = default;
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
  
  virtual bool canReportAbout(InDetConditions::Hierarchy h) const override;
  
  virtual bool isGood(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
  virtual bool isGood(const IdentifierHash& elementIdHash, const EventContext& ctx) const override;
  virtual void getDetectorElementStatus(const EventContext& ctx, InDet::SiDetectorElementStatus &element_status,
                                        SG::WriteCondHandle<InDet::SiDetectorElementStatus>* whandle) const override;
 
  virtual std::set<IdentifierHash> getErrorSet(int errorType, const EventContext& ctx) const override; // Used by SCTRawDataProviderTool and others
 
  virtual unsigned int tempMaskedChips(const Identifier& moduleId, const EventContext& ctx) const override; // Internally used
  virtual unsigned int abcdErrorChips(const Identifier& moduleId, const EventContext& ctx) const override; // Internally used
 
 
private:
  enum N_ELEMENTS { N_CHIPS_PER_SIDE = 6, N_SIDES = 2, N_STRIPS_PER_CHIP = 128, N_STRIPS_PER_SIDE = N_STRIPS_PER_CHIP*N_CHIPS_PER_SIDE };
 
  ToolHandle<ISCT_ConfigurationConditionsTool> m_config{this, "ConfigTool",
      "SCT_ConfigurationConditionsTool/InDetSCT_ConfigurationConditionsTool", "Tool to retrieve SCT Configuration Tool"};
 
  SG::ReadHandleKey<IDCInDetBSErrContainer> m_bsIDCErrContainerName{this, "IDCByteStreamErrContainer", "SCT_ByteStreamErrs", "SCT BS error key for IDC variant"};
  SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
 
  const SCT_ID* m_sct_id{nullptr};
  IdContext m_cntx_sct;
  uint64_t m_badErrorMask{};
 
  mutable SG::SlotSpecificObj<std::mutex> m_cacheMutex ATLAS_THREAD_SAFE;
  struct IDCCacheEntry {
    EventContext::ContextEvt_t eventId{EventContext::INVALID_CONTEXT_EVT}; // invalid event ID for the start
    const IDCInDetBSErrContainer_Cache* IDCCache{nullptr};
    // infomations in granularity of Chips
    // misisng value mean that the map need updating
    // 0 as the value denotes no error
    // error encoding is as follows: pattern for a module has length of 6 bits, side 0 is encoded in bits 0-5, side 1 in bits 6-11
    // so bit 0 is for chip 0 on side 0, bit 1 is for chip 1 on side 0, ..., and bit 11 is for chip 5 on side 1
    std::unordered_map<size_t, unsigned int> tempMaskedChips;
    std::unordered_map<size_t, unsigned int> abcdErrorChips;
 
  
    //Record the set number of the idcErrContainer, if the set numbers are the same, skip the fillData process to save time.
    unsigned int m_set_number = 0;
    
    void reset(EventContext::ContextEvt_t evtId, const IDCInDetBSErrContainer_Cache* cache) {
      eventId = evtId;
      IDCCache = cache;
      m_set_number = 0;
      tempMaskedChips.clear();
      abcdErrorChips.clear();
    }
 
    bool needsUpdate(const EventContext& ctx) const {
      return eventId != ctx.evt() or eventId == EventContext::INVALID_CONTEXT_EVT;
    }
 
  };
  mutable SG::SlotSpecificObj<IDCCacheEntry> m_eventCache ATLAS_THREAD_SAFE;

  [[nodiscard]] const IDCInDetBSErrContainer* getContainer(const EventContext& ctx) const;
  mutable std::atomic_uint m_nRetrievalFailure{0};

  [[nodiscard]] IDCCacheEntry* getCacheEntry(const EventContext& ctx) const;

  StatusCode fillData(const EventContext& ctx) const;
 
  bool isGoodChip(const Identifier& stripId, const EventContext& ctx) const;
  int getChip(const Identifier& stripId, const EventContext& ctx) const;
 
  // For isRODSimulatedData, HVisOn and isCondensedReadout
  const InDetDD::SiDetectorElement* getDetectorElement(const IdentifierHash& waferHash, const EventContext& ctx) const;

  std::pair<StatusCode, unsigned int> getErrorCodeWithCacheUpdate(const Identifier& id, const EventContext& ctx, std::unordered_map<size_t, unsigned int>& whereExected) const;
 
};
 
#endif // SCT_ByteStreamErrorsTool_h