PixelConditionsSummaryTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef PIXELCONDITIONSSERVICES_PIXELCONDITIONSSUMMARYTOOL_H
#define PIXELCONDITIONSSERVICES_PIXELCONDITIONSSUMMARYTOOL_H
 
 
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "InDetConditionsSummaryService/IDetectorElementStatusTool.h"
#include "InDetConditionsSummaryService/IInDetConditionsTool.h"
 
#include "GaudiKernel/ServiceHandle.h"
#include "Gaudi/Property.h"
 
#include "AthenaKernel/SlotSpecificObj.h"
 
#include "InDetByteStreamErrors/IDCInDetBSErrContainer.h"
#include "Identifier/Identifier.h"
#include "Identifier/IdentifierHash.h"
#include "InDetIdentifier/PixelID.h"
 
#include "PixelConditionsData/PixelDeadMapCondData.h"
#include "PixelConditionsData/PixelDCSStateData.h"
#include "PixelConditionsData/PixelDCSStatusData.h"
#include "PixelConditionsData/PixelTDAQData.h"
 
#include "StoreGate/ReadCondHandleKey.h"
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "InDetReadoutGeometry/SiDetectorElementStatus.h"
#include "PixelReadoutGeometry/PixelModuleDesign.h"
 
#include <string>
#include <mutex>
#include <tuple>
#include <memory>
#include <cstdint>//uint64_t
#include <vector>
#include <bitset>
#include <limits>
 
class PixelConditionsSummaryTool: public AthAlgTool, virtual public IDetectorElementStatusTool,virtual public IInDetConditionsTool {
  public:
    static InterfaceID& interfaceID();
 
    PixelConditionsSummaryTool(const std::string& type, const std::string& name, const IInterface* parent);
    virtual ~PixelConditionsSummaryTool();
    virtual StatusCode initialize() override;
 
    virtual bool isActive(const Identifier& elementId, const InDetConditions::Hierarchy h, const EventContext& ctx) const override final;
    virtual bool isActive(const IdentifierHash& moduleHash, const EventContext& ctx) const override final;
    virtual bool isActive(const IdentifierHash& moduleHash, const Identifier& elementId, const EventContext& ctx)  const override final;
    virtual double activeFraction(const IdentifierHash& moduleHash, const Identifier & idStart, const Identifier & idEnd, const EventContext& ctx)  const override final;
 
    virtual bool isGood(const Identifier& elementId, const InDetConditions::Hierarchy h, const EventContext& ctx) const override final;
    virtual bool isGood(const IdentifierHash& moduleHash, const EventContext& ctx) const override final;
    virtual bool isGood(const IdentifierHash& moduleHash, const Identifier& elementId, const EventContext& ctx, const IDCCacheEntry* cacheEntry=nullptr) const override final;
    virtual double goodFraction(const IdentifierHash & moduleHash, const Identifier & idStart, const Identifier & idEnd, const EventContext& ctx) const override final;
 
    virtual std::unique_ptr<InDet::SiDetectorElementStatus>
    getDetectorElementStatus(const EventContext& ctx,
                             SG::WriteCondHandle<InDet::SiDetectorElementStatus>* whandle) const override;
 
    virtual bool hasBSError(const IdentifierHash& moduleHash, const EventContext& ctx, const IDCCacheEntry* cacheEntry=nullptr) const override final;
    virtual bool hasBSError(const IdentifierHash& moduleHash, Identifier pixid, const EventContext& ctx, const IDCCacheEntry* cacheEntry=nullptr) const override final;
    virtual uint64_t getBSErrorWord(const IdentifierHash& moduleHash, const EventContext& ctx, const IDCCacheEntry* cacheEntry=nullptr) const override final;
    virtual uint64_t getBSErrorWord(const IdentifierHash& moduleHash, const int index, const EventContext& ctx, const IDCCacheEntry* cacheEntry=nullptr) const override final;
 
    // public version of getCacheEntry
    virtual IDCCacheEntry* getCacheEntryOut(const EventContext& ctx) const override final;
 
    bool checkChipStatus(IdentifierHash moduleHash, Identifier pixid, const EventContext& ctx) const;
 
  private:
    uint64_t getBSErrorWord(const InDetDD::PixelModuleDesign *p_design,
                            const int index,
                            const EventContext& ctx,
                            const IInDetConditionsTool::IDCCacheEntry* cacheEntry) const;
   bool hasBSError(const InDetDD::PixelModuleDesign *p_design,
                   const IdentifierHash& moduleHash,
                   const EventContext& ctx,
                   const IInDetConditionsTool::IDCCacheEntry* cacheEntry) const;
    const InDetDD::SiDetectorElement *getDetectorEelement(const IdentifierHash& moduleHash, const EventContext& ctx) const;
    const PixelID* m_pixelID{};
 
    std::vector<std::string> m_isActiveStatus;
    std::vector<std::string> m_isActiveStates;
    std::vector<int> m_activeState;
    std::vector<int> m_activeStatus;
    unsigned int m_activeStateMask{};  
    unsigned int m_activeStatusMask{}; 
 
    Gaudi::Property<bool> m_useByteStreamFEI4
    {this, "UseByteStreamFEI4", false, "Switch of the ByteStream error for FEI4"};
 
    Gaudi::Property<bool> m_useByteStreamFEI3
    {this, "UseByteStreamFEI3", false, "Switch of the ByteStream error for FEI3"};
 
    Gaudi::Property<bool> m_useByteStreamRD53
    {this, "UseByteStreamRD53", false, "Switch of the ByteStream error for RD53"};
 
    SG::ReadCondHandleKey<PixelDCSStateData> m_condDCSStateKey
    {this, "PixelDCSStateCondData", "PixelDCSStateCondData", "Pixel FSM state key"};
 
    SG::ReadCondHandleKey<PixelDCSStatusData> m_condDCSStatusKey
    {this, "PixelDCSStatusCondData", "PixelDCSStatusCondData", "Pixel FSM status key"};
 
    SG::ReadCondHandleKey<PixelTDAQData> m_condTDAQKey
    {this, "PixelTDAQCondData", "", "Pixel TDAQ conditions key"}; //Default empty - legacy option
 
    SG::ReadCondHandleKey<PixelDeadMapCondData> m_condDeadMapKey
    {this, "PixelDeadMapCondData", "PixelDeadMapCondData", "Pixel deadmap conditions key"};
 
    SG::ReadHandleKey<IDCInDetBSErrContainer>  m_BSErrContReadKey
    {this, "PixelByteStreamErrs", "PixelByteStreamErrs", "PixelByteStreamErrs container key"};
 
    SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> m_pixelDetEleCollKey
    {this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"};
 
    SG::ReadHandleKey<InDet::SiDetectorElementStatus> m_pixelDetElStatusEventKey
       {this, "PixelDetElStatusEventDataBaseKey", "", "Optional event data key of an input SiDetectorElementStatus on which the newly created object will be based."};
    SG::ReadCondHandleKey<InDet::SiDetectorElementStatus> m_pixelDetElStatusCondKey
       {this, "PixelDetElStatusCondDataBaseKey", "" , "Optional conditions data key of an input SiDetectorElementStatus on which the newly created object will be based."};
 
    Gaudi::Property< bool> m_activeOnly
       {this, "ActiveOnly", false, "Module and chip status will only reflect whether the modules or chips are active not necessarily whether the signals are good."};
 
    const uint64_t m_missingErrorInfo{std::numeric_limits<uint64_t>::max()-3000000000};
 
    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;
 
      void reset( EventContext::ContextEvt_t evtId, const IDCInDetBSErrContainer_Cache* cache) {
        eventId = evtId;
        IDCCache   = cache;
      }
 
      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; // Guarded by m_cacheMutex

    [[nodiscard]] const IDCInDetBSErrContainer* getContainer(const EventContext& ctx) const;

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

    std::unique_ptr<InDet::SiDetectorElementStatus>
    createDetectorElementStatus(const EventContext& ctx,
                                SG::WriteCondHandle<InDet::SiDetectorElementStatus>* whandle) const;
 
};
 
inline InterfaceID& PixelConditionsSummaryTool::interfaceID(){
  static InterfaceID IID_PixelConditionsSummaryTool("PixelConditionsSummaryTool", 1, 0);
  return IID_PixelConditionsSummaryTool;
}
 
inline bool PixelConditionsSummaryTool::checkChipStatus(IdentifierHash moduleHash, Identifier pixid, const EventContext& ctx) const {
  std::bitset<16> chipStatus(SG::ReadCondHandle<PixelDeadMapCondData>(m_condDeadMapKey, ctx)->getChipStatus(moduleHash));
  if (chipStatus.any()) {
 
     const InDetDD::SiDetectorElement *element = getDetectorEelement(moduleHash,ctx);
     const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign*>(&element->design());
 
     std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx
        = InDetDD::PixelDiodeTree::makeCellIndex(m_pixelID->phi_index(pixid),
                                                 m_pixelID->eta_index(pixid));
     InDetDD::PixelDiodeTree::DiodeProxy si_param ( p_design->diodeProxyFromIdx(diode_idx));
     std::uint32_t chFE = p_design->getFE(si_param);
 
    std::bitset<16> circ;
    circ.set(chFE);
    if ((chipStatus&circ).any()) { return false; }
  }
  return true;
}
 
#endif