SCT_RodDecoder.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETRAWDATABYTESTREAM_SCT_RODDECODER_H 
#define INDETRAWDATABYTESTREAM_SCT_RODDECODER_H
 
#include "SCT_RawDataByteStreamCnv/ISCT_RodDecoder.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
#include "InDetByteStreamErrors/IDCInDetBSErrContainer.h"
#include "InDetIdentifier/SCT_ID.h"
#include "SCT_ConditionsData/SCT_ByteStreamErrors.h"
#include "SCT_Cabling/ISCT_CablingTool.h"
#include "SCT_ConditionsTools/ISCT_ByteStreamErrorsTool.h"
#include "SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h"
#include "Identifier/IdContext.h"
 
#include "GaudiKernel/ToolHandle.h"
 
#include <atomic>
#include <cstdint>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <array>
 
class IdentifierHash;
 
 
class SCT_RodDecoderErrorsHelper {
public:
  SCT_RodDecoderErrorsHelper(IDCInDetBSErrContainer& idcContainer)
    : errorsIDC{ idcContainer } {}
  ~SCT_RodDecoderErrorsHelper() {
    for (auto [id, err]: accumulatedErrors) {
      errorsIDC.setOrDrop(id, err);
    }
  }
  void noerror(const IdentifierHash id) {
    accumulatedErrors[id]; // this adds 0 (no error) for an ID
  }
 
  void add(const IdentifierHash id, SCT_ByteStreamErrors::ErrorType etype) {
    SCT_ByteStreamErrors::addError(accumulatedErrors[id], etype);
  }
 
  void removeIfEmpty(const IdentifierHash id) {
    if (accumulatedErrors[id]==0) {
      accumulatedErrors.erase(id);
    } 
  }
 
  std::map<IdentifierHash, IDCInDetBSErrContainer::ErrorCode> accumulatedErrors;
  IDCInDetBSErrContainer& errorsIDC;
};
 
 
class SCT_RodDecoder : public extends<AthAlgTool, ISCT_RodDecoder>
{
  struct CacheHelper {
    IdentifierHash skipHash, lastHash;
    const std::vector<IdentifierHash>* vecHash;
  };
 
 public: 
 
  SCT_RodDecoder(const std::string& type, const std::string& name, const IInterface* parent);
  
  virtual ~SCT_RodDecoder() = default;
 
  virtual StatusCode initialize() override;
 
  virtual StatusCode finalize() override;
 
  virtual StatusCode fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag,
                                    SCT_RDO_Container& rdoIDCont,
                                    IDCInDetBSErrContainer& errs,
                                    DataPool<SCT3_RawData>* dataItemsPool,
                                    const EventContext& ctx,
                                    const std::vector<IdentifierHash>* vecHash = nullptr) const override;
 
 private:
 
  enum SCT_DecoderNumbers { N_SIDES = 2,
                            N_CHIPS_PER_SIDE = 6,
                            N_STRIPS_PER_CHIP = 128,
                            N_STRIPS_PER_SIDE = N_CHIPS_PER_SIDE*N_STRIPS_PER_CHIP,
  };
 
  struct SharedData {
    static constexpr int INVALID_STRIP = N_STRIPS_PER_SIDE;
 
    bool condensedMode{true}; // Condensed mode or Expanded mode for each link if superCondensedMode is false
 
    // Variables necessary for makeRDO
    int strip {INVALID_STRIP};
    int groupSize{0};
    int timeBin{0};
    IdentifierHash linkIDHash; // Determined from header and changed for links using Rx redundancy (waferHash)
    Identifier collID; // Determined from linkIDHash (waferID)
    int errors{0}; // Encodes the errors on the header (bit 4: error in condensed mode 1st hit, bit 5: error in condensed mode 2nd hit)
    CacheHelper cache{}; // For the trigger
    std::vector<int> errorHit;
 
    int side {-1};
    int oldSide  {-1};
    int oldStrip {INVALID_STRIP};
    int linkNumber{0}; // Determined from header and may be changed for links using Rx redundancy
 
    std::array<bool, N_STRIPS_PER_SIDE*N_SIDES> saved{};//defaults to false
 
    // For MissingLinkHeaderError
    bool foundMissingLinkHeaderError{false};
    std::unordered_set<IdentifierHash> foundHashes;
    struct Hasher {
         std::size_t operator()(const IdentifierHash &hash) const { return hash.value();}
    };
    std::unordered_map<IdentifierHash, std::unique_ptr<SCT_RDO_Collection>, Hasher> rdoCollMap; // If SCT_RDO_Collection* is nullptr, it means the collection is already present in the container.
    std::unordered_map<IdentifierHash, SCT_RDO_Container::IDC_WriteHandle, Hasher> writeHandleMap;
 
    bool foundHeader{false};
 
    SharedData() {
      writeHandleMap.reserve( 72);
      rdoCollMap.reserve( 72 );
    }
 
    void reset() {
      strip = INVALID_STRIP;
      oldStrip = INVALID_STRIP;
      oldSide = -1;
      groupSize = 0;
      errors = 0;
      saved.fill(false);
      errorHit.clear();
    };
    void setOld() {
      oldStrip = strip;
      oldSide = side;
      groupSize = 0;
    }
    void setSaved(const bool isOld, const int code) {
      if (isOld) {
        saved.at(oldSide*N_STRIPS_PER_SIDE + oldStrip) = code;
      }
      else {
        saved.at(   side*N_STRIPS_PER_SIDE +    strip) = code;
      }
    }
    bool isSaved(const bool isOld) {
      if (isOld) {
        unsigned int idx = static_cast<std::size_t>(oldSide*N_STRIPS_PER_SIDE + oldStrip);
        return idx  < saved.size() ? saved[idx] : true;
      }
      else {
        const unsigned int  idx = static_cast<unsigned int>(side*N_STRIPS_PER_SIDE +    strip);
        return idx < saved.size() ? saved[idx] : true;
      }
    }
    bool isStripValid() const {
       return static_cast<unsigned int>(strip) < N_STRIPS_PER_SIDE;
    }
    bool isOldStripValid() const {
       return static_cast<unsigned int>(oldStrip) < N_STRIPS_PER_SIDE;
    }
    void setStripInvalid()  {
       strip = INVALID_STRIP;
    }
    void setCollection(const SCT_ID* sctID,
                       const IdentifierHash& waferHash,
                       SCT_RDO_Container& rdoIDCont,
                       DataPool<SCT3_RawData>* dataItemsPool,
                       SCT_RodDecoderErrorsHelper& errs) {
      linkIDHash = waferHash;
      collID = sctID->wafer_id(linkIDHash);
      foundHashes.insert(linkIDHash);
      if (rdoCollMap.count(linkIDHash)==0) { // The collection is not in the local map.
        writeHandleMap.insert(std::pair<IdentifierHash, SCT_RDO_Container::IDC_WriteHandle>(linkIDHash, rdoIDCont.getWriteHandle(linkIDHash)));
        if (writeHandleMap[linkIDHash].alreadyPresent()) { // The collection is already in the container.
          rdoCollMap[linkIDHash] = nullptr;
          writeHandleMap.erase(linkIDHash); // lock is released
        }
        else { // Create a new collection for linkIDHash
          std::unique_ptr<SCT_RDO_Collection> rdoColl{std::make_unique<SCT_RDO_Collection>(linkIDHash)};
          rdoColl->setIdentifier(collID);
          if(dataItemsPool){
          //pool will own
            rdoColl->clear(SG::VIEW_ELEMENTS);
          }
          rdoCollMap[linkIDHash] = std::move(rdoColl);
          errs.noerror(linkIDHash); // make sure the error information is filled for this hash
        }
      }
    }
  };
 
  int makeRDO(const bool isOld,
              SharedData& data,
              CacheHelper& cache,
              DataPool<SCT3_RawData>* dataItemsPool) const;
 
  StatusCode addRODError(uint32_t rodID, SCT_ByteStreamErrors::ErrorType error,
                         SCT_RodDecoderErrorsHelper& errs,
                         const std::unordered_set<IdentifierHash>* foundHashes=nullptr) const;
  StatusCode addSingleError(const IdentifierHash& hashID,
                            SCT_ByteStreamErrors::ErrorType error,
                            SCT_RodDecoderErrorsHelper& errs) const;
 
  StatusCode setFirstTempMaskedChip(const IdentifierHash& hashID, 
                                    unsigned int firstTempMaskedChip, 
                                    SCT_RodDecoderErrorsHelper& errs) const;
 
  StatusCode processHeader(const uint16_t inData,
                           const uint32_t robID,
                           SharedData& data,
                           SCT_RDO_Container& rdoIDCont,
                           DataPool<SCT3_RawData>* dataItemsPool,
                           CacheHelper& cache,
                           SCT_RodDecoderErrorsHelper& errs,
                           bool& hasError,
                           bool& breakNow,
                           const EventContext& ctx) const;
 
  StatusCode processSuperCondensedHit(const uint16_t inData,
                                      const uint32_t robID,
                                      SharedData& data,
                                      SCT_RDO_Container& rdoIDCont,
                                      DataPool<SCT3_RawData>* dataItemsPool,
                                      CacheHelper& cache,
                                      SCT_RodDecoderErrorsHelper& errs,
                                      bool& hasError,
                                      const EventContext& ctx) const;
 
  StatusCode processCondensedHit(const uint16_t inData,
                                 const uint32_t robID,
                                 SharedData& data,
                                 SCT_RDO_Container& rdoIDCont,
                                 DataPool<SCT3_RawData>* dataItemsPool,
                                 CacheHelper& cache,
                                 SCT_RodDecoderErrorsHelper& errs,
                                 bool& hasError,
                                 const EventContext& ctx) const;
 
  StatusCode processExpandedHit(const uint16_t inData,
                                const uint32_t robID,
                                SharedData& data,
                                SCT_RDO_Container& rdoIDCont,
                                DataPool<SCT3_RawData>* dataItemsPool,
                                CacheHelper& cache,
                                SCT_RodDecoderErrorsHelper& errs,
                                bool& hasError,
                                const EventContext& ctx) const;
 
  StatusCode processABCDError(const uint16_t inData,
                              const uint32_t robID,
                              SharedData& data,
                              SCT_RodDecoderErrorsHelper& errs,
                              bool& hasError) const;
 
  StatusCode processRawData(const uint16_t inData,
                            const uint32_t robID,
                            SharedData& data,
                            SCT_RodDecoderErrorsHelper& errs,
                            bool& hasError) const;
 
  StatusCode processTrailer(const uint16_t inData,
                            const uint32_t robID,
                            SharedData& data,
                            SCT_RodDecoderErrorsHelper& errs,
                            bool& hasError) const;
 
  const SCT_ID* m_sctID{nullptr};
 
  IdContext m_contextSCT;
 
  ToolHandle<ISCT_CablingTool> m_cabling{this, 
                                         "SCT_CablingTool", 
                                         "SCT_CablingTool", 
                                         "Tool to retrieve SCT Cabling"};
 
  ToolHandle<ISCT_ConfigurationConditionsTool> m_configTool{this, 
                                                            "ConfigTool",
                                                            "SCT_ConfigurationConditionsTool/InDetSCT_ConfigurationConditionsTool", 
                                                            "Tool to retrieve SCT Configuration Tool"};
 
  mutable std::atomic_uint m_singleCondHitNumber{0};
 
  mutable std::atomic_uint m_pairedCondHitNumber{0};
  
  mutable std::atomic_uint m_firstExpHitNumber{0};
  
  mutable std::atomic_uint m_evenExpHitNumber{0};
  
  mutable std::atomic_uint m_lastExpHitNumber{0};
  
  mutable std::atomic_uint m_headNumber{0};
  
  mutable std::atomic_uint m_trailerNumber{0};
  
  mutable std::atomic_uint m_headErrorBCID{0};
  
  mutable std::atomic_uint m_headErrorLvl1ID{0};
  
  mutable std::atomic_uint m_headErrorTimeout{0};
  
  mutable std::atomic_uint m_headErrorFormatter{0};
  
  mutable std::atomic_uint m_headErrorPreamble{0};
  
  mutable std::atomic_uint m_trailerErrorOverflow{0};
  
  mutable std::atomic_uint m_trailerErrorLimit{0};
  
  mutable std::atomic_uint m_trailerErrorBit{0};
  
  mutable std::atomic_uint m_configDataBit{0};
  
  mutable std::atomic_uint m_flagErrorBit{0};
  
  mutable std::atomic_uint m_condHit1Error{0};
  
  mutable std::atomic_uint m_condHit2Error{0};
  
  mutable std::atomic_uint m_chipNumberError{0};
  
  mutable std::atomic_uint m_unknownDataFormat{0};
  
  mutable std::atomic_uint m_nHits{0};
  
  mutable std::atomic_uint m_nRDOs{0};
  
  mutable std::atomic_uint m_maskedLinkNumber{0};
  
  mutable std::atomic_uint m_maskedRODNumber{0};
  
  mutable std::atomic_uint m_rodClockErrorNumber{0};
  
  mutable std::atomic_uint m_truncatedRODNumber{0};
  
  mutable std::atomic_uint m_numMissingLinkHeader{0};
  
  std::vector<bool> m_swapPhiReadoutDirection{};
};
 
#endif //SCT_RAWDATABYTESTREAM_SCT_RODDECODER_H