EMECDetectorManager.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/SystemOfUnits.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "RDBAccessSvc/IRDBRecord.h"
#include "RDBAccessSvc/IRDBRecordset.h"
#include "RDBAccessSvc/IRDBAccessSvc.h"
 
#include "GeoModelInterfaces/IGeoModelSvc.h"
#include "GeoModelInterfaces/IGeoDbTagSvc.h"
#include "GeoModelUtilities/DecodeVersionKey.h"
#include "LArReadoutGeometry/EMECDetectorManager.h"
#include "LArReadoutGeometry/EMECDetectorRegion.h"
#include "LArReadoutGeometry/EMECDetDescr.h"
#include "StoreGate/StoreGateSvc.h"
#include "LArHV/LArHVManager.h"
// Class EMECDetectorManager 
 
EMECDetectorManager::EMECDetectorManager(const EMECHVManager* hvManagerInner
                     , const EMECHVManager* hvManagerOuter
                     , const EMECPresamplerHVManager* presamplerHVManager)
  : m_MagicNumbers(new EMECMagicNumbers())
  , m_presamplerHVManager(presamplerHVManager)
{
  setName("LArEMEC");
  
  for (unsigned int r=0;r<6;r++) {
    for (unsigned int s=0;s<4;s++) {
      for (unsigned int io=0;io<2;io++) {
    for (unsigned int e=0;e<2;e++) {
      m_DetRegionsRandom[r][s][io][e]=nullptr;
    }
      }
    }
  }
 
  m_HVManager[0].store (hvManagerInner);
  m_HVManager[1].store (hvManagerOuter);
 
  // The EMEC gets and managers certain arrays needed to build descriptors.  Here is that:
  ISvcLocator *svcLocator = Gaudi::svcLocator();
 
  SmartIF<IGeoModelSvc> geoModel{svcLocator->service("GeoModelSvc")};
  if(!geoModel.isValid())
    throw std::runtime_error("Error in EMECDetectorManager, cannot access GeoModelSvc");
 
  SmartIF<IGeoDbTagSvc> geoDbTagSvc{svcLocator->service("GeoDbTagSvc")};
  if(!geoDbTagSvc.isValid())
    throw std::runtime_error("Error in EMECDetectorManager, cannot access GeoDbTagSvc");
 
  SmartIF<IRDBAccessSvc> rdbAccess{svcLocator->service(geoDbTagSvc->getParamSvcName())};
  if(!rdbAccess.isValid())
    throw std::runtime_error("Error in EMECDetectorManager, cannot access RDBAccessSvc");
 
  std::string larKey, larNode;
  if(geoDbTagSvc->getSqliteReader()==nullptr) {
    DecodeVersionKey larVersionKey(geoModel, "LAr");
    larKey  = larVersionKey.tag();
    larNode = larVersionKey.node();
  }
 
  IRDBRecordset_ptr emecSamplingSep       = rdbAccess->getRecordsetPtr("EmecSamplingSep", larKey, larNode);
  if (emecSamplingSep->size()==0)   throw std::runtime_error("Error getting EmecSamplingSep table");
 
  const IRDBRecord *ess = (*emecSamplingSep)[0];
  for (int j=0;j<7;j++)  m_ziw.push_back(ess->getDouble("ZIW",j)*Gaudi::Units::cm);
  for (int j=0;j<44;j++) m_zsep12.push_back(ess->getDouble("ZSEP12",j)*Gaudi::Units::cm);
  for (int j=0;j<22;j++) m_zsep23.push_back(ess->getDouble("ZSEP23",j)*Gaudi::Units::cm);
 
  IRDBRecordset_ptr emecMagicNumbers       = rdbAccess->getRecordsetPtr("EmecMagicNumbers", larKey, larNode);
  if (emecMagicNumbers->size()==0) {
    emecMagicNumbers       = rdbAccess->getRecordsetPtr("EmecMagicNumbers", "EmecMagicNumbers-00");
    if (emecMagicNumbers->size()==0) {
      throw std::runtime_error("Error getting EmecMagicNumbers table");
    }
  }
  m_MagicNumbers->focalToRef        =(*emecMagicNumbers)[0]->getDouble("FOCALTOREF")*Gaudi::Units::mm;
  m_MagicNumbers->refToActive       =(*emecMagicNumbers)[0]->getDouble("REFTOACTIVE")*Gaudi::Units::mm;
  m_MagicNumbers->activeLength      =(*emecMagicNumbers)[0]->getDouble("ACTIVELENGTH")*Gaudi::Units::mm;
  m_MagicNumbers->refToPresampler   =(*emecMagicNumbers)[0]->getDouble("REFTOPRESAMPLER")*Gaudi::Units::mm;
  m_MagicNumbers->presamplerLength  =(*emecMagicNumbers)[0]->getDouble("PRESAMPLERLENGTH")*Gaudi::Units::mm;
}
 
 
EMECDetectorManager::~EMECDetectorManager() {
  for (unsigned int i=0;i<getNumDetectorRegions();i++) delete m_DetRegionsIterative[i]; 
  delete m_MagicNumbers;
}
 
 
 
//## Other Operations (implementation)
EMECDetectorManager::DetectorRegionConstIterator EMECDetectorManager::beginDetectorRegion () const
{
  return m_DetRegionsIterative.begin();
}
 
EMECDetectorManager::DetectorRegionConstIterator EMECDetectorManager::endDetectorRegion () const
{
  return m_DetRegionsIterative.end();
}
 
const EMECDetectorRegion * EMECDetectorManager::getDetectorRegion (unsigned int endcap, unsigned int sampling, unsigned int region, bool inner) const
{
  return m_DetRegionsRandom[region][sampling][inner ? 1 : 0][endcap];
}
 
unsigned int EMECDetectorManager::getNumDetectorRegions () const
{
  return m_DetRegionsIterative.size();
}
 
PVConstLink EMECDetectorManager::getTreeTop (unsigned int i) const
{
 return m_treeTop[i];
}
 
unsigned int EMECDetectorManager::getNumTreeTops () const
{
  return m_treeTop.size();
}
 
void EMECDetectorManager::addDetectorRegion (const EMECDetectorRegion *region)
{
  m_DetRegionsIterative.push_back(region);
  size_t iregion = region->getRegionIndex();
  if (iregion >= 6) {
    throw std::out_of_range("EMECDetectorManager::addDetectorRegion -- region");
  }
  size_t isampling = region->getSamplingIndex();
  if (isampling >= 4) {
    throw std::out_of_range("EMECDetectorManager::addDetectorRegion -- sampling");
  }
  // coverity[checked_return]
  size_t iradius = region->getRadialIndex();
  if (iradius >= 2) {
    throw std::out_of_range("EMECDetectorManager::addDetectorRegion -- radius");
  }
  size_t iendcap = region->getEndcapIndex();
  if (iendcap >= 2) {
    throw std::out_of_range("EMECDetectorManager::addDetectorRegion -- endcap");
  }
  m_DetRegionsRandom[iregion][isampling][iradius][iendcap] = region;
}
 
void EMECDetectorManager::addTreeTop (const PVLink& treeTop)
{
  m_treeTop.push_back(treeTop);
}
 
const EMECHVManager& EMECDetectorManager::getHVManager (EMECHVManager::IOType io) const
{
  const EMECHVManager* out = m_HVManager[io].get();
  if (!out) {
    //Support lazy initialization for testbeams
    ServiceHandle<StoreGateSvc> detStore ("DetectorStore", "HECHVManager");
    const LArHVManager *manager{nullptr};
    if (detStore->retrieve(manager)==StatusCode::SUCCESS) {
      out = &(manager->getEMECHVManager(io));
      m_HVManager[io].set (out);
    }
  }
  if (!out) {
    throw std::runtime_error ("EMECDetectorManager::getHVManager: Can't find LArHVManager in DetectorStore");
  }
  return *out;
}
 
const EMECPresamplerHVManager& EMECDetectorManager::getPresamplerHVManager () const
{
  const EMECPresamplerHVManager* out = m_presamplerHVManager.get();
  if (!out) {
    ServiceHandle<StoreGateSvc> detStore ("DetectorStore", "HECHVManager");
    const LArHVManager *manager{nullptr};
    if (detStore->retrieve(manager)==StatusCode::SUCCESS) {
      out = &(manager->getEMECPresamplerHVManager());
      m_presamplerHVManager.set (out);
    }
  }
  if (!out) {
    throw std::runtime_error ("EMECDetectorManager::getPresamplerHVManager: Can't find LArHVManager in DetectorStore");
  }
  return *out;
}