ITkPixelCablingAlg.cxx

Go to the documentation of this file.

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

 
//package includes
#include "ITkPixelCablingAlg.h"
 
//indet includes
#include "InDetIdentifier/PixelID.h"
#include "PixelReadoutGeometry/PixelDetectorManager.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
#include "PixelReadoutGeometry/PixelModuleDesign.h"
 
 
//Athena includes
#include "Identifier/Identifier.h"
#include "Identifier/IdentifierHash.h"
#include "PathResolver/PathResolver.h"
#include "AthenaKernel/IOVInfiniteRange.h"
 
 
 
// Gaudi include
#include "GaudiKernel/EventIDRange.h"
 
 
//STL
#include <iostream>
#include <fstream>
 
// CREST
#include <chai/Database.h>
 
//json
#include <nlohmann/json.hpp>
 
 
 
// Constructor
ITkPixelCablingAlg::ITkPixelCablingAlg(const std::string& name, ISvcLocator* pSvcLocator):
  AthCondAlgorithm(name, pSvcLocator)
{
}
 
//
StatusCode
ITkPixelCablingAlg::initialize() {
  // ITkPixelID
  ATH_CHECK(detStore()->retrieve(m_idHelper, "PixelID"));
  // det manager
  if (m_useTestCabling) ATH_CHECK(detStore()->retrieve(m_detManager, "ITkPixel"));
  // Read Cond Key
  ATH_CHECK( m_readKey.initialize() );
  // Write Cond Handle
  ATH_CHECK(m_writeKey.initialize());
 
  return StatusCode::SUCCESS;
}
 
 
//
StatusCode
ITkPixelCablingAlg::execute(const EventContext& ctx) const {
  // Write Cond Handle
  SG::WriteCondHandle<ITkPixelCablingData> writeHandle = SG::makeHandle(m_writeKey, ctx);
  if (writeHandle.isValid()) {
    ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid."
                  << ". In theory this should not be called, but may happen"
                  << " if multiple concurrent events are being processed out of order.");
    return StatusCode::SUCCESS;
  }
  SG::ReadCondHandle<AthenaAttributeList> readHandle{m_readKey, ctx};
  const AthenaAttributeList* attr{*readHandle};
 
  if (attr==nullptr) {
    ATH_MSG_ERROR("Failed to retrieve AthenaAttributeList with key " << m_readKey.key());
    return StatusCode::FAILURE;
  }
  const std::string& pl = (*attr)["cabling"].data<std::string>();
 
  // Construct the output Cond Object and fill it in
  std::unique_ptr<ITkPixelCablingData> pCabling = std::make_unique<ITkPixelCablingData>();
  
  //For development purposes, generate a dummy cabling structure, using the existing
  //offline IDs and dummy online ones. It's problematic to deal with quads easily, as
  //they have one offline ID, but up to 4 online IDs. If there will be virtual elinks
  //for merged quads or if there's no data merging, the situation is not mappable for
  //the encoding offline -> online map. Once could at most map to certain bits that
  //would be shared between the 4 online IDs. In the decoding direction, the
  //online->offline will be always mappable, although it would be degenerate mapping.
  if (m_useTestCabling){
    ATH_MSG_DEBUG("Using test cabling generated with ITkPixelCablingAlg::generateTestCabling(...)");
    ATH_CHECK(generateTestCabling(pCabling));
    pCabling->print();
    if (writeHandle.record(EventIDRange(IOVInfiniteRange::infiniteRunLB()), std::move(pCabling)).isFailure()) {
        return StatusCode::FAILURE;
    }
    
    return StatusCode::SUCCESS;
  }
 
  ATH_CHECK(fillFromCREST(pCabling, pl));
  const int numEntries = pCabling->size();
  ATH_MSG_DEBUG(numEntries << " entries were made to the identifier map.");
 
  // Define validity of the output cond object and record it
  const EventIDBase start{EventIDBase::UNDEFNUM, EventIDBase::UNDEFEVT, 0, 0, EventIDBase::UNDEFNUM, EventIDBase::UNDEFNUM};
  const EventIDBase stop{EventIDBase::UNDEFNUM, EventIDBase::UNDEFEVT, EventIDBase::UNDEFNUM-1, EventIDBase::UNDEFNUM-1, EventIDBase::UNDEFNUM, EventIDBase::UNDEFNUM};
  const EventIDRange rangeW{start, stop};
  if (writeHandle.record(rangeW, std::move(pCabling)).isFailure()) {
    ATH_MSG_FATAL("Could not record ITkPixelCablingData " << writeHandle.key() 
                  << " with EventRange " << rangeW
                  << " into Conditions Store");
    return StatusCode::FAILURE;
  }
  ATH_MSG_VERBOSE("recorded new conditions data object " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
  return (numEntries==0) ? (StatusCode::FAILURE) : (StatusCode::SUCCESS);
}
 
StatusCode ITkPixelCablingAlg::generateTestCabling(std::unique_ptr<ITkPixelCablingData>& cabling) const {
    //We'll loop over all known hashes, and create a sensible cabling situation
    //for testing purposes, create online ID by shifting the wafer ID by two bits, allowing
    //to accommodate the non-merged quads with 4 online links vs. one offline entity.
    //What's used as the online "base" (32 bit) is just the offline ID (64bit) >> 32.
    //Lowest two bits are always 0 in the base - in fact, at least 2 bytes are. Fine for testing.
    
    std::unordered_set<uint32_t> seen;
 
    for (size_t hash = 0; hash < m_idHelper->wafer_hash_max(); hash++){
        Identifier id = m_idHelper->wafer_id(hash);
        uint32_t onID = (id.get_identifier32().get_compact());
        
        const InDetDD::SiDetectorElement *element = m_detManager->getDetectorElement(id);
        const InDetDD::PixelModuleDesign *p_design = static_cast<const InDetDD::PixelModuleDesign *>(&element->design());
 
        //a dummy sourceID - has nothing to do with reality, and is intended
        //for testing purposes only
        
        uint32_t sourceID = std::abs(m_idHelper->barrel_ec(id)) << 26 | m_idHelper->layer_disk(id) << 20;
        if (seen.insert(sourceID).second) cabling->addSourceID(sourceID);
 
        ITkPixelCabling::ModuleType moduleType;
        ITkPixelCabling::TransformType moduleTransform;
        if (p_design->numberOfCircuits() == 4){
            //it's a quad
            
            //Let's make the entire layer 1 and 2 non-merged.
            //We can experiment with this, but we're also after
            //a proof-of-principle here.
            if (m_idHelper->barrel_ec(id) == 0 && (m_idHelper->layer_disk(id) == 1 || m_idHelper->layer_disk(id) == 2)){
                //Non-merged quad has 4 online IDs mappend onto 1 offline,
                //differentiated by 2-bit chip ID
                moduleType = ITkPixelCabling::ModuleType::SimpleQuad;
                moduleTransform = ITkPixelCabling::TransformType::NominalQuad;
                cabling->addEntryOnOff(onID | 0b00, ITkPixelCabling::ModuleInfo(id, moduleType, moduleTransform));
                cabling->addEntryOnOff(onID | 0b01, ITkPixelCabling::ModuleInfo(id, moduleType, moduleTransform));
                cabling->addEntryOnOff(onID | 0b10, ITkPixelCabling::ModuleInfo(id, moduleType, moduleTransform));
                cabling->addEntryOnOff(onID | 0b11, ITkPixelCabling::ModuleInfo(id, moduleType, moduleTransform));
 
            }
            else{
                //Merged quads have 1:1 online:offline correspondence.
                //Don't need to invent any substructure, but keep it
                //consistent with the quads
                moduleType = ITkPixelCabling::ModuleType::MergedQuad;
                moduleTransform = ITkPixelCabling::TransformType::NominalQuad;
                cabling->addEntryOnOff(onID, ITkPixelCabling::ModuleInfo(id, moduleType, moduleTransform));
            }
            
            //We can also fill in the offline->online map
            //Were are creating the "base" online ID, i. e. without the chip ID
            cabling->addEntryOffOn(id, ITkPixelCabling::ModuleInfo<ITkPixelOnlineId>(onID, moduleType, moduleTransform));
            
 
            //Fill in also the updated ROB-structure-respecting map with some dummy values
            cabling->addEntryOffOn((onID >> 8) | 0x00000000, ITkPixelOnlineId(sourceID, (onID >> 8) | 0x00000000));
            cabling->addEntryOffOn((onID >> 8) | 0x40000000, ITkPixelOnlineId(sourceID, (onID >> 8) | 0x40000000));
            cabling->addEntryOffOn((onID >> 8) | 0x80000000, ITkPixelOnlineId(sourceID, (onID >> 8) | 0x80000000));
            cabling->addEntryOffOn((onID >> 8) | 0xC0000000, ITkPixelOnlineId(sourceID, (onID >> 8) | 0xC0000000));
            cabling->addTransformType(onID, ITkPixelCabling::TransformType::NominalQuad);
        
        }
        else {
            
            //All triplets map 1:1 to chips. Keeping the online
            //"base" ID consistently shifted - we're dealing with chip 00
            ITkPixelCabling::ModuleType moduleType = m_idHelper->barrel_ec(id) == 0 ? ITkPixelCabling::ModuleType::IBTriplet : ITkPixelCabling::ModuleType::IECTriplet;
            ITkPixelCabling::TransformType moduleTransform = m_idHelper->barrel_ec(id) == 0 ? ITkPixelCabling::TransformType::NominalIBTriplet : ITkPixelCabling::TransformType::NominalIECTriplet;
            cabling->addEntryOnOff(onID, ITkPixelCabling::ModuleInfo(id, moduleType, moduleTransform));
            
            //We can also fill in the offline->online map
            //Were are creating the "base" online ID, i. e. without the chip ID
            cabling->addEntryOffOn(id, ITkPixelCabling::ModuleInfo<ITkPixelOnlineId>(onID, moduleType, moduleTransform));
            
            //Fill in also the updated ROB-structure-respecting map with some dummy values
            cabling->addEntryOffOn((onID >> 8), ITkPixelOnlineId(sourceID, onID >> 8));
            if (m_idHelper->barrel_ec(id) == 0){
                cabling->addTransformType(onID, ITkPixelCabling::TransformType::NominalIBTriplet);
            }
            else {
                cabling->addTransformType(onID, ITkPixelCabling::TransformType::NominalIECTriplet);
            }
        }
 
    }
    
    return StatusCode::SUCCESS;
}
 
StatusCode ITkPixelCablingAlg::fillFromCREST(std::unique_ptr<ITkPixelCablingData>& cabling, const std::string& c) const {
 
    // Remove Python bytes representation: b'...'
    std::string s=c;
    if (c.size() >= 3 &&
        c.substr(0, 2) == "b'" &&
        c.back() == '\''){
        s = c.substr(2, c.size() - 3);
    }
    // Parse JSON
    nlohmann::json config = nlohmann::json::parse(s);
 
    std::unordered_set<uint32_t> seen;
 
    for (const auto& entry : config) {
        
        const uint32_t detectorResourceID = std::stoul(entry.at("DetectorResourceID").get<std::string>(), nullptr, 16);
 
        const uint32_t trueDetectorResourceID = std::stoul(entry.at("TrueDetectorResourceID").get<std::string>(), nullptr, 16);
 
        const uint32_t sourceID = std::stoul(entry.at("SourceID").get<std::string>(), nullptr, 16);
 
        cabling->addEntryOffOn(detectorResourceID & ITkPixelCabling::OFFLINE_DRID_MASK, ITkPixelOnlineId(sourceID, detectorResourceID));
 
        if (seen.insert(sourceID).second) cabling->addSourceID(sourceID);
 
        uint64_t moduleID = (static_cast<uint64_t>(ITkPixelCabling::dridToModuleID(trueDetectorResourceID)) << 32);
 
        Identifier id(static_cast<Identifier::value_type>(moduleID));
        if      (m_idHelper->barrel_ec(id) == 0 && m_idHelper->layer_disk(id) == 0) cabling->addTransformType(ITkPixelCabling::dridToModuleID(trueDetectorResourceID), ITkPixelCabling::TransformType::NominalIBTriplet);
        else if (m_idHelper->barrel_ec(id) != 0 && (m_idHelper->layer_disk(id) == 0 || m_idHelper->layer_disk(id) == 1) ) cabling->addTransformType(ITkPixelCabling::dridToModuleID(trueDetectorResourceID), ITkPixelCabling::TransformType::NominalIECTriplet);
        else cabling->addTransformType(ITkPixelCabling::dridToModuleID(trueDetectorResourceID), ITkPixelCabling::TransformType::NominalQuad);
        ATH_MSG_DEBUG(std::hex << " key " << (detectorResourceID & ITkPixelCabling::OFFLINE_DRID_MASK) << " detectorResourceID " << detectorResourceID << " trueDetectorResourceID " << trueDetectorResourceID << " sourceID " << sourceID);
    }
 
    return StatusCode::SUCCESS;
}