MdtCablingJsonDumpAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include "MdtCablingJsonDumpAlg.h"
#include "StoreGate/ReadCondHandle.h"
#include "MuonReadoutGeometry/MdtReadoutElement.h"
#include "CxxUtils/ArrayHelper.h"
#include "MuonCablingData/MdtMezzanineCard.h"
#include <fstream>
 
namespace {
   struct TdcIdentifier: public MdtCablingOnData {
        uint8_t tdcId{0};
        bool operator==(const TdcIdentifier& other) const {
            return this->MdtCablingOnData::operator==(other) && tdcId == other.tdcId;
        }
        bool operator!=(const TdcIdentifier& other) const { return !((*this) == other); }
        bool operator<(const TdcIdentifier& other) const {
          if (this->MdtCablingOnData::operator!=(other)) return this->MdtCablingOnData::operator<(other);
        return tdcId < other.tdcId;
     }
     TdcIdentifier(const MdtCablingData& cabling):
        MdtCablingOnData{cabling},
        tdcId{cabling.tdcId} {} 
   };
 
  using Mapping = MdtMezzanineCard::Mapping;
  using OfflineCh = MdtMezzanineCard::OfflineCh;
 
}
 
MdtCablingJsonDumpAlg::MdtCablingJsonDumpAlg(const std::string& name, ISvcLocator* pSvcLocator):
    AthAlgorithm(name,pSvcLocator) {}
 
 
StatusCode MdtCablingJsonDumpAlg::initialize(){
  ATH_CHECK(m_idHelperSvc.retrieve());
  ATH_CHECK(m_DetectorManagerKey.initialize());
  ATH_CHECK(m_cablingKey.initialize());
  return StatusCode::SUCCESS;
} 
 
StatusCode MdtCablingJsonDumpAlg::execute() {
  const EventContext& ctx = Gaudi::Hive::currentContext();
  ATH_MSG_INFO("Dump cabling & mezzanines into JSON file");
 
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> detectorMgr{m_DetectorManagerKey, ctx};
  if (!detectorMgr.isValid()){
      ATH_MSG_FATAL("Failed to retrieve the Detector manager "<<m_DetectorManagerKey.fullKey());
      return StatusCode::FAILURE;
  }
 
  SG::ReadCondHandle<MuonMDT_CablingMap> cabling{m_cablingKey,ctx};
  if (!cabling.isValid()) {
     ATH_MSG_ERROR("Failed to retrieve the Mdt cabling "<<m_cablingKey.fullKey());
     return StatusCode::FAILURE;
  }
  const MdtIdHelper& idHelper = m_idHelperSvc->mdtIdHelper();
 
  std::vector<MdtMezzanineCard> cached_cards{};
  std::set<MdtCablingData> cached_chnls{};
 
  for (auto det_itr = idHelper.detectorElement_begin(); det_itr != idHelper.detectorElement_end(); ++det_itr){
    const MuonGM::MdtReadoutElement* readEle = detectorMgr->getMdtReadoutElement(*det_itr);
    if (!readEle) {
        ATH_MSG_DEBUG("Detector element does not exist. ");
        continue;
    }
    const Identifier station_id = idHelper.elementID(readEle->identify());
    ATH_MSG_DEBUG("Check station "<<m_idHelperSvc->toString(station_id));   
    MdtMezzanineCard dummy_card(Mapping{}, readEle->getNLayers(), -1);
    
    std::map<TdcIdentifier, Mapping> chamber_mezz{};
    for (int layer = 1 ; layer <= readEle->getNLayers(); ++layer){         
      for (int tubeInLayer = 1 ; tubeInLayer <= readEle->getNtubesperlayer(); ++tubeInLayer) {
          bool is_valid{false};
          const Identifier tube_id = idHelper.channelID(station_id, readEle->getMultilayer(), 
                                                        layer, tubeInLayer, is_valid);
              if (!is_valid) {
                ATH_MSG_VERBOSE("Invalid element");
                continue;
              }
              MdtCablingData cabling_data{};
              cabling->convert(tube_id,cabling_data);
              if (!cabling->getOnlineId(cabling_data, msgStream())) {
                ATH_MSG_ERROR("Could no retrieve a valid online channel for "<<m_idHelperSvc->toString(tube_id));
                return StatusCode::FAILURE;
              }
              const TdcIdentifier tdc_id{cabling_data};
              if (chamber_mezz.find(tdc_id) == chamber_mezz.end()) {
                chamber_mezz[tdc_id] = make_array<uint8_t,24>(MdtMezzanineCard::NOTSET);
              }
              chamber_mezz[tdc_id][cabling_data.channelId] = dummy_card.tubeNumber(layer, tubeInLayer);
         }
    }
    for (auto&[tdc, mezz_mapping] : chamber_mezz) {
        MdtCablingData mezzCablingId{};
        
        static_cast<MdtCablingOnData&>(mezzCablingId) = tdc;
        mezzCablingId.tdcId = tdc.tdcId;
        
        MdtTdcOnlSorter chipInCab =  cabling->getOnlineConvMap().at(tdc).all_modules.at(tdc.tdcId);
        static_cast<MdtCablingOffData&>(mezzCablingId) = chipInCab->offId();
        mezzCablingId.tube = chipInCab->tubeZero();
        
        const uint8_t tubeOffSet = (mezzCablingId.tube-1)%dummy_card.numTubesPerLayer();
        if (tubeOffSet) {
           MdtMezzanineCard remap{mezz_mapping, dummy_card.numTubeLayers(), 0};
           for (size_t chan = 0 ; chan < mezz_mapping.size(); ++chan) {           
              const OfflineCh tube_lay = remap.offlineTube(chan, msgStream());
              if (!tube_lay.isValid) continue;
              uint8_t tubeNumber = tube_lay.tube + tubeOffSet + 1;
              mezz_mapping[chan] = remap.tubeNumber(tube_lay.layer, tubeNumber);
           }
        }
        Mapping& mtmp = mezz_mapping; // Work around clang15 compilation error.
        std::vector<MdtMezzanineCard>::const_iterator itr = std::find_if(cached_cards.begin(), cached_cards.end(), 
            [&dummy_card, &mtmp](const MdtMezzanineCard& card ){
               if (dummy_card.numTubeLayers() != card.numTubeLayers()) return false;
               for (size_t ch =0; ch < mtmp.size(); ++ch) {
                  if (mtmp[ch] != card.tdcToTubeMap()[ch]) return false;
               }
              return true;
        });
        if (itr != cached_cards.end()) {
          mezzCablingId.mezzanine_type = itr->id();
        } else {
          cached_cards.emplace_back(mezz_mapping, dummy_card.numTubeLayers(), cached_cards.size() + 10);
          if (!cached_cards.back().checkConsistency(msgStream())) {
            ATH_MSG_ERROR("Wrong assignment for "<<mezzCablingId);
            return StatusCode::FAILURE;
          }
          mezzCablingId.mezzanine_type = cached_cards.back().id();
        }
        cached_chnls.insert(std::move(mezzCablingId));
    }
 
 
    
    }    
    {
        std::ofstream summary{m_summaryTxt};
        if (!summary.good()) {
          ATH_MSG_ERROR("Failed to write "<<m_summaryTxt);
          return StatusCode::FAILURE;
        }
        summary<<"Extracted "<<cached_cards.size()<<" mezzanine card layouts and "
              <<cached_chnls.size()<<" chamber channels. "<<std::endl<<std::endl<<std::endl;
        for (const MdtMezzanineCard& card : cached_cards) {
          summary<<card;
          MdtCablingOffData chamb{};
          for (const MdtCablingData& cabling : cached_chnls) {
              if (cabling.mezzanine_type != card.id()) continue;
              if (chamb != cabling) {
                chamb = cabling;
                summary<<std::endl<<" *** "<<idHelper.stationNameString(chamb.stationIndex);             
                summary<<static_cast<int>(std::abs(chamb.eta));
                summary<<(chamb.eta > 0 ? "A" : "C");
                summary<<static_cast<int>(chamb.phi);
                summary<<"M"<<static_cast<int>(chamb.multilayer);
                summary<<" --- tdcs: ";
              }
              summary<<static_cast<int>(cabling.tdcId)<<", ";
          }
          summary<<std::endl<<std::endl
                  <<"##############################################################"<<std::endl;
        }
    }
    {
      std::ofstream mezz_json{m_mezzJSON};
      if (!mezz_json.good()) {
          ATH_MSG_ERROR("Failed to write "<<m_summaryTxt);
          return StatusCode::FAILURE;
      }
      mezz_json<<"["<<std::endl;
      for (size_t i = 0; i < cached_cards.size() ; ++i) {
         const MdtMezzanineCard& card  = cached_cards[i];
         mezz_json<<"     {"<<std::endl;
         mezz_json<<"       \"mezzId\": "<<static_cast<int>(card.id())<<","<<std::endl;
         mezz_json<<"       \"nTubeLayer\": "<<static_cast<int>(card.numTubeLayers())<<","<<std::endl;
         mezz_json<<"       \"tdcToTubeMap\": [";
         for (size_t ch = 0 ; ch < card.tdcToTubeMap().size(); ++ch) {
           mezz_json<<static_cast<int>(card.tdcToTubeMap()[ch]);
           if (ch + 1 != card.tdcToTubeMap().size())mezz_json<<",";
         }
         mezz_json<<"]"<<std::endl;
         mezz_json<<"     }";       
         if (i +1 != cached_cards.size()) mezz_json<<",";
         mezz_json<<std::endl;
      }
      mezz_json<<"]";
    }
    {
      std::ofstream chamb_json{m_cablingJSON};
      if (!chamb_json.good()) {
         ATH_MSG_FATAL("Failed to write "<<m_cablingJSON);
         return StatusCode::FAILURE;
      }
      chamb_json<<"["<<std::endl;
      size_t i =0;
      for (const MdtCablingData& chamb : cached_chnls){ 
        chamb_json<<"    {"<<std::endl;
        chamb_json<<"     \"station\": \""<<idHelper.stationNameString(chamb.stationIndex)<<"\","<<std::endl;
        chamb_json<<"     \"eta\": "<<static_cast<int>(chamb.eta)<<","<<std::endl;
        chamb_json<<"     \"phi\": "<<static_cast<int>(chamb.phi)<<","<<std::endl;
        chamb_json<<"     \"ml\": "<<static_cast<int>(chamb.multilayer)<<","<<std::endl;
        chamb_json<<"     \"subDet\": "<<static_cast<int>(chamb.subdetectorId)<<","<<std::endl;
        chamb_json<<"     \"csm\": "<<static_cast<int>(chamb.csm)<<","<<std::endl;
        chamb_json<<"     \"mrod\": "<<static_cast<int>(chamb.mrod)<<","<<std::endl;
        chamb_json<<"     \"tdcId\": "<<static_cast<int>(chamb.tdcId)<<","<<std::endl;
        chamb_json<<"     \"mezzId\": "<<static_cast<int>(chamb.mezzanine_type)<<","<<std::endl;
        chamb_json<<"     \"tubeZero\": "<<static_cast<int>(chamb.tube)<<std::endl;
        chamb_json<<"    }";
        if (i +1 != cached_chnls.size()) chamb_json<<",";
        chamb_json<<std::endl;
        ++i;
      }
      chamb_json<<"]"<<std::endl;
    }
 
    
  return StatusCode::SUCCESS;
}