SiRegSelCondAlg.cxx

Go to the documentation of this file.

 
 
#include "GaudiKernel/EventIDRange.h"
#include "StoreGate/WriteCondHandle.h"
 
 
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
 
#include "InDetIdentifier/SCT_ID.h"
#include "InDetIdentifier/PixelID.h"
 
#include "SiRegSelCondAlg.h"
 
#include "IRegionSelector/IRegSelLUTCondData.h"
#include "RegSelLUT/RegSelSiLUT.h"
#include <cmath>
 
 
SiRegSelCondAlg::SiRegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
  AthCondAlgorithm( name, pSvcLocator ),
  m_managerName(""),
  m_printTable(false)
{ 
  ATH_MSG_DEBUG( "SiRegSelCondAlg::SiRegSelCondAlg() " << name );
  declareProperty( "PrintTable",  m_printTable=false );  
  declareProperty( "ManagerName", m_managerName );  
}
 
 
 
 
StatusCode SiRegSelCondAlg::initialize()
{
  ATH_MSG_DEBUG("SiRegSelCondAlg::initialize() ");
  ATH_CHECK(m_pixCablingKey.initialize(!m_pixCablingKey.empty()));
  ATH_CHECK(m_sctCablingKey.initialize(!m_sctCablingKey.empty()));
  m_useCabling = !m_pixCablingKey.empty() || !m_sctCablingKey.empty();
  ATH_CHECK(m_detEleCollKey.initialize());
  ATH_CHECK(m_tableKey.initialize());
  ATH_MSG_INFO("SiRegSelCondAlg::initialize() " << m_tableKey );
  return StatusCode::SUCCESS;
}
 
 
 
 
StatusCode SiRegSelCondAlg::execute(const EventContext& ctx)  const
{
  ATH_MSG_DEBUG("SiRegSelCondAlg::execute() -- enter -- ");
  
  ATH_MSG_DEBUG( "Creating region selector table " << m_tableKey );
 
  SG::WriteCondHandle<IRegSelLUTCondData> lutCondData( m_tableKey, ctx );
  // Do we have a valid Write Cond Handle for current time?
  if (lutCondData.isValid()) {
    ATH_MSG_DEBUG("CondHandle " << lutCondData.fullKey() << " is already valid." );
    return StatusCode::SUCCESS;
  }
 
 
  std::unique_ptr<SG::ReadCondHandle<PixelCablingCondData> > pixCabling;
  std::unique_ptr<SG::ReadCondHandle<SCT_CablingData> >      sctCabling;
 
  EventIDRange id_range;
 
  ATH_MSG_DEBUG( "RegSelCondAlg:" << name() );
  
  if(m_useCabling){
 
    if (m_managerName=="SCT") { // SCT
      sctCabling = std::make_unique<SG::ReadCondHandle<SCT_CablingData> >( m_sctCablingKey, ctx );
      if( !sctCabling->range( id_range ) ) {
    ATH_MSG_ERROR("Failed to retrieve validity range for " << sctCabling->key());
    return StatusCode::FAILURE;
      }
    }
    else if(m_managerName=="Pixel"){ // PIXEL
 
      ATH_MSG_DEBUG( "RegSelCondAlg: " << name() << "\t" << m_pixCablingKey );
      ATH_MSG_DEBUG( "RegSelCondAlg: " << ctx );
      ATH_MSG_DEBUG( "RegSelCondAlg: " << id_range << "( initial range )" );
 
      pixCabling = std::make_unique<SG::ReadCondHandle<PixelCablingCondData> >( m_pixCablingKey, ctx );
      if( !pixCabling->range( id_range ) ) {
    ATH_MSG_ERROR("Failed to retrieve validity range for " << pixCabling->key() << " : " << id_range );
    return StatusCode::FAILURE;
      }
      ATH_MSG_DEBUG( "RegSelCondAlg: " << id_range << "( final range )" );
    }
 
  }
 
  ATH_MSG_DEBUG( "RegSelCondAlg:" << name() << " done" );
 
 
  std::unique_ptr<RegSelSiLUT> rd;
 
  const bool isPixelLikeManager = (m_managerName == "Pixel" || m_managerName == "PLR");
  if (isPixelLikeManager) {
    rd = std::make_unique<RegSelSiLUT>(RegSelSiLUT::PIXEL);
  } else {
    rd = std::make_unique<RegSelSiLUT>(RegSelSiLUT::SCT);
  }
 
  // Get detector elements (=alignment) in condition store
  const InDetDD::SiDetectorElementCollection* elements = nullptr;
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> detEle(m_detEleCollKey, ctx);
  if (detEle.isValid()) {
    elements = detEle.retrieve();
  }
  if (elements==nullptr) {
    ATH_MSG_ERROR("Failed to retrieve InDetDD::SiDetectorElementCollection for " << m_managerName);
    return StatusCode::FAILURE;
  }
  // Since this condition algorithm for HLT, we want to run this only at the first event of a run.
  // We do not take the intersect of ranges of cabling and detector elements.
  // We use the range of cabling.
 
  if(!m_useCabling){
    if( !detEle.range( id_range ) ) {
      ATH_MSG_ERROR("Failed to retrieve validity range for " << detEle.key() << " : " << id_range );
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG( "RegSelCondAlg: " << id_range << "( final range )" );
  }
 
  for (const InDetDD::SiDetectorElement* element : *elements) {
 
    if (element) {
 
      IdentifierHash hashId = element->identifyHash();    
      
      ATH_MSG_VERBOSE( "Found element with HashId = " << hashId );
   
      // new region selector detector element extent
 
      double rMin, rMax, zMin, zMax, phiMin, phiMax;
 
      rMin    = element->rMin();
      rMax    = element->rMax();
      zMin    = element->zMin();
      zMax    = element->zMax();
      phiMin  = element->phiMin();
      phiMax  = element->phiMax();
 
 
      int      barrelEC  = 0; 
      int      layerDisk = 0;
      uint32_t     robId = 0;
 
      // PLR uses its own detector type flag, but its offline helper inherits
      // from PixelID and should follow the pixel-like RegionSelector path.
      if (element->isPixel() || element->isPLR() || m_managerName == "PLR") {
 
    const PixelID* pixelId = dynamic_cast<const PixelID*>(element->getIdHelper());
    if ( pixelId!=nullptr ) { 
      barrelEC  = pixelId->barrel_ec(element->identify());
      // DBM is pixel-only. PLR is pixel-like for RegionSelector purposes,
      // but it must not be filtered out by the DBM-specific barrel_ec cut.
      if ( m_managerName != "PLR" && std::fabs(barrelEC)>3 ) continue;
      layerDisk = pixelId->layer_disk(element->identify());
      if(m_useCabling && pixCabling) robId=(*pixCabling)->find_entry_offrob(element->identify());
      else robId = 0;
    }
    else { 
      ATH_MSG_ERROR("Could not get PIXEL_ID for " << element->getIdHelper() );
    }
 
      } else { // it's an SCT element
 
    const SCT_ID* sctId = dynamic_cast<const SCT_ID*>(element->getIdHelper());
    if ( sctId!=nullptr ) {      
      barrelEC  = sctId->barrel_ec(element->identify());
      layerDisk = sctId->layer_disk(element->identify());
      // Avoid use of SCT_CablingTool. Instead of
      // robId=m_sctCablingTool->getRobIdFromOfflineId(element->identify());
      if(m_useCabling && sctCabling) robId = ((*sctCabling)->getOnlineIdFromHash(element->identifyHash())).rod();
      else robId = 0;
    }
    else { 
      ATH_MSG_ERROR("Could not get SCT_ID for " << element->getIdHelper() );
    }
 
      }
 
 
      // create module for lookup table      
 
      RegSelModule smod( zMin, zMax, rMin, rMax, phiMin, phiMax, layerDisk, barrelEC, robId, hashId );
      
      rd->addModule( smod );
      
      ATH_MSG_DEBUG( smod );
      
      ATH_MSG_VERBOSE( "\t robId = " << robId
               << " barrelEC = " << barrelEC 
               << ", layerDisk = " << layerDisk 
               << ", phiMin, phiMax = " << phiMin/CLHEP::degree << " " << phiMax/CLHEP::degree
               << ", rMin = " << rMin/CLHEP::mm << " mm, rMax = " << rMax/CLHEP::mm << " mm" );  
      
    }
  }
  
  
  ATH_MSG_DEBUG( " initialising new map " );
 
  rd->initialise();
 
  // write out new new LUT to a file if need be
  if ( m_printTable ) rd->write( name()+".map" );
 
  IRegSelLUTCondData* rcd = new IRegSelLUTCondData( std::move(rd) );
  
  try { 
    if( lutCondData.record( id_range, rcd ).isFailure() ) {
      ATH_MSG_ERROR( "Could not record " << m_tableKey 
             << " " << lutCondData.key()
             << " with range " << id_range );  
      return StatusCode::FAILURE;   
    } 
    ATH_MSG_INFO( "RegSelCondAlg LUT recorded: " << m_tableKey);
  }
  catch (...) { 
    ATH_MSG_ERROR("SiRegSelCondAlg::execute() failed to record table: " << m_tableKey);
    return StatusCode::FAILURE;   
  }   
  
  
  ATH_MSG_DEBUG("SiRegSelCondAlg::execute() -- exit -- ");
 
  return StatusCode::SUCCESS;
}