LArLATOMEMappingAlg.cxx

Go to the documentation of this file.

//dear emacs, this is -*-c++-*-
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#include "LArLATOMEMappingAlg.h"
#include "AthenaPoolUtilities/AthenaAttributeList.h"
#include "CoralBase/Blob.h"
#include "CoralBase/AttributeList.h"
 
#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
#include "LArIdentifier/LArOnline_SuperCellID.h"
 
StatusCode LArLATOMEMappingAlg::initialize() {
 
  ATH_MSG_DEBUG("initializing");
 
  // Read Handles
  ATH_CHECK( m_readKey.initialize() );
  ATH_CHECK( m_writeKey.initialize() );
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode LArLATOMEMappingAlg::execute(const EventContext& ctx) const {
  ATH_MSG_DEBUG("executing");
 
  SG::WriteCondHandle<LArLATOMEMapping> writeHandle{m_writeKey, ctx};
  
  if (writeHandle.isValid()) {
    ATH_MSG_DEBUG("Found valid write handle");
    return StatusCode::SUCCESS;
  }  
 
  SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey, ctx};
  const CondAttrListCollection * catr{*readHandle};
 
  if (catr==nullptr) {
    ATH_MSG_ERROR("Failed to retrieve CondAttrListCollection with key " << m_readKey.key());
    return StatusCode::FAILURE;
  }
 
 
  writeHandle.addDependency(readHandle);
 
  //Loop over COOL channels:
  CondAttrListCollection::const_iterator chanIt=catr->begin();
  CondAttrListCollection::const_iterator chanIt_e=catr->end();
  // needs a length of blobs first
  const coral::Blob& bls = chanIt->second["SourceIDs"].data<coral::Blob>();
  unsigned nLat=bls.size()/sizeof(uint32_t);
  std::unique_ptr<LArLATOMEMapping> latomeMap=std::make_unique<LArLATOMEMapping>(nLat);
 
  for (;chanIt!=chanIt_e;++chanIt) {
    
    const coral::AttributeList& attr = chanIt->second;
    const coral::Blob& blobsourceId=attr["SourceIDs"].data<coral::Blob>();
    unsigned nLatome=blobsourceId.size()/sizeof(uint32_t);
    const coral::Blob& blobonlineId=attr["OnlineIDs"].data<coral::Blob>();
    unsigned nChan=blobonlineId.size()/blobsourceId.size();
    const uint32_t* pblobsourceId=static_cast<const uint32_t*>(blobsourceId.startingAddress());  
    const uint32_t* pblobonlineId=static_cast<const uint32_t*>(blobonlineId.startingAddress());  
  
    if (nChan!=N_LATOME_CHANNELS) {
       ATH_MSG_ERROR("Number of channels read from DB (" << nChan << ") does not match expected "
          <<N_LATOME_CHANNELS << ")");
       return StatusCode::FAILURE;
    }
 
    for (unsigned i=0;i<nLatome;++i) {
      const unsigned sid=pblobsourceId[i];
      ATH_MSG_DEBUG("Latome SID: "<<sid);
      std::pair<unsigned, std::vector<HWIdentifier> > entry{sid,{}};
      entry.second.reserve(N_LATOME_CHANNELS);
      for (unsigned j=0;j<N_LATOME_CHANNELS ;++j) {
        const HWIdentifier hwid=HWIdentifier(Identifier32(pblobonlineId[i*N_LATOME_CHANNELS + j]));
        if (hwid.is_valid() && hwid != 0) {
          entry.second.push_back(hwid);
        } else {
          entry.second.push_back(latomeMap->m_hwidEmpty);
        }
      }
      latomeMap->m_map.insert(std::move(entry));
    }//end loop over LATOME sourceIDs
    ATH_MSG_INFO("Done reading latome mapping");
    ATH_MSG_INFO("Found " << nLatome << " LATOMEs "); 
  } // end over cool channels
  
  if(writeHandle.record(std::move(latomeMap)).isFailure()) {
    ATH_MSG_ERROR("Could not record LArLATOMEMapping object with " 
          << writeHandle.key() 
          << " with EventRange " << writeHandle.getRange()
          << " into Conditions Store");
    return StatusCode::FAILURE;
    }
  ATH_MSG_INFO("recorded new " << writeHandle.key() << " with range " << writeHandle.getRange() << " into Conditions Store");
 
  return StatusCode::SUCCESS;
}