PixelDetectorFactoryLite Class Reference

#include <PixelDetectorFactoryLite.h>

Inheritance diagram for PixelDetectorFactoryLite:

Collaboration diagram for PixelDetectorFactoryLite:

Public Member Functions
	PixelDetectorFactoryLite (GeoModelIO::ReadGeoModel *sqliteReader, PixelGeoModelAthenaComps *athenaComps, const PixelSwitches &switches)
	PixelDetectorFactoryLite ()=delete
	PixelDetectorFactoryLite (const PixelDetectorFactoryLite &right)=delete
const PixelDetectorFactoryLite &	operator= (const PixelDetectorFactoryLite &right)=delete
virtual void	create (GeoPhysVol *world) override
virtual const InDetDD::PixelDetectorManager *	getDetectorManager () const override
StoreGateSvc *	detStore ()
const StoreGateSvc *	detStore () const
const IGeoDbTagSvc *	geoDbTagSvc () const
IRDBAccessSvc *	rdbAccessSvc ()
const IGeometryDBSvc *	geomDB () const
MsgStream &	msg (MSG::Level lvl) const
bool	msgLvl (MSG::Level lvl)
InDetDD::AthenaComps *	getAthenaComps ()

Private Member Functions
void	doChecks ()

Private Attributes
GeoModelIO::ReadGeoModel *	m_sqliteReader {nullptr}
InDetDD::PixelDetectorManager *	m_detectorManager {nullptr}
std::unique_ptr< PixelGeometryManager >	m_geometryManager
bool	m_useDynamicAlignFolders {false}
std::shared_ptr< std::map< std::string, GeoFullPhysVol * > >	m_mapFPV
std::shared_ptr< std::map< std::string, GeoAlignableTransform * > >	m_mapAX
InDetDD::AthenaComps *	m_athenaComps

Detailed Description

Definition at line 28 of file PixelDetectorFactoryLite.h.

Constructor & Destructor Documentation

PixelDetectorFactoryLite() [1/3]

PixelDetectorFactoryLite::PixelDetectorFactoryLite	(	GeoModelIO::ReadGeoModel *	sqliteReader,
		PixelGeoModelAthenaComps *	athenaComps,
		const PixelSwitches &	switches )

Definition at line 36 of file PixelDetectorFactoryLite.cxx.

  : InDetDD::DetectorFactoryBase(athenaComps)
  , m_sqliteReader (sqliteReader)    
{
  // Create the detector manager
  m_detectorManager = new PixelDetectorManager(detStore());
 
  // Create the geometry manager.
  m_geometryManager =  std::make_unique<DBPixelGeoManager>(athenaComps);
 
  // Pass the switches
  m_geometryManager->SetServices(switches.services());
  m_geometryManager->SetServicesOnLadder(switches.servicesOnLadder());
  m_geometryManager->SetDC1Geometry(switches.dc1Geometry());
  m_geometryManager->SetAlignable(switches.alignable());
  m_geometryManager->SetInitialLayout(switches.initialLayout());
  m_geometryManager->SetIBL(switches.ibl());
 
  // get switch for DBM
  m_geometryManager->SetDBMFlag(switches.dbm());
  msg(MSG::INFO) << "DBM switch = SetDBMFlag: "<< m_geometryManager->dbm() << endmsg;
   
  // Create SiCommonItems ans store it in geometry manager. 
  // These are items that are shared by all elements
  std::unique_ptr<SiCommonItems> commonItems{std::make_unique<SiCommonItems>(athenaComps->getIdHelper())};
  m_geometryManager->setCommonItems(commonItems.get());
 
  // Add SiCommonItems to PixelDetectorManager to hold and delete it.
  m_detectorManager->setCommonItems(std::move(commonItems));
 
  // Determine if initial layer and tag from the id dict are consistent
  bool initialLayoutIdDict = (m_detectorManager->tag() == "initial_layout");
  if (m_geometryManager->InitialLayout() != initialLayoutIdDict ) {
    msg(MSG::WARNING) << "IdDict tag is \"" << m_detectorManager->tag() 
              << "\" which is inconsistent with the layout choosen!" << endmsg;
  } 
 
  //
  // Set Version information
  //
  std::string versionTag  = m_geometryManager->versionTag();
  std::string versionName = m_geometryManager->versionName();
  std::string layout = m_geometryManager->versionLayout();
  std::string description = m_geometryManager->versionDescription() ;
  int versionMajorNumber = 5;
  int versionMinorNumber = 1;
  int versionPatchNumber = 0;
 
  if (m_geometryManager->InitialLayout()) {
    layout = "Initial";
  }
  
  InDetDD::Version version(versionTag,
               versionName, 
               layout, 
               description, 
               versionMajorNumber,
               versionMinorNumber,
               versionPatchNumber);
  m_detectorManager->setVersion(version);
 
  m_useDynamicAlignFolders = switches.dynamicAlignFolders();
 
  if (sqliteReader) {
    m_mapFPV = std::shared_ptr<std::map<std::string, GeoFullPhysVol*>> (new std::map<std::string, GeoFullPhysVol*> (m_sqliteReader->getPublishedNodes<std::string, GeoFullPhysVol*>("Pixel")));
    m_mapAX  = std::shared_ptr< std::map<std::string, GeoAlignableTransform*>> (new std::map<std::string, GeoAlignableTransform *> (m_sqliteReader->getPublishedNodes<std::string, GeoAlignableTransform*>("Pixel")));
  }
 
} 

PixelDetectorFactoryLite() [2/3]

PixelDetectorFactoryLite::PixelDetectorFactoryLite ( )

delete

PixelDetectorFactoryLite() [3/3]

PixelDetectorFactoryLite::PixelDetectorFactoryLite ( const PixelDetectorFactoryLite & right )

delete

Member Function Documentation

create()

void PixelDetectorFactoryLite::create ( GeoPhysVol * world )

overridevirtual

Definition at line 111 of file PixelDetectorFactoryLite.cxx.

{
  msg(MSG::INFO) << "Building Pixel Detector" << endmsg;
  msg(MSG::INFO) << " " << m_detectorManager->getVersion().fullDescription() << endmsg;
 
  // Printout the parameters that are different in DC1 and DC2.
  m_geometryManager->SetCurrentLD(0);
  m_geometryManager->SetBarrel();
  msg(MSG::DEBUG) << " B-Layer basic eta pitch: " << m_geometryManager->DesignPitchZ()/Gaudi::Units::micrometer << "um"  << endmsg;  
  msg(MSG::DEBUG) << " B-Layer sensor thickness: " << m_geometryManager->PixelBoardThickness()/Gaudi::Units::micrometer << "um"  << endmsg;   
    
  
  // The top level volume
  GeoFullPhysVol *pPixelEnvelopeVol = (*m_mapFPV)["Pixel_Envelope"];
    
  // Create the Lite Pixel Envelope...
  GeoPixelEnvelope pe(m_detectorManager, m_geometryManager.get(), m_sqliteReader, m_mapFPV, m_mapAX);
  pe.Build() ;
 
  GeoAlignableTransform * transform = (*m_mapAX)["Pixel_Envelope"];
 
  // Store alignable transform
  Identifier id = m_geometryManager->getIdHelper()->wafer_id(0,0,0,0);
  m_detectorManager->addAlignableTransform(2, id, transform, pPixelEnvelopeVol);
 
  // Add this to the list of top level physical volumes:             
  m_detectorManager->addTreeTop(pPixelEnvelopeVol);
 
  
  // Initialize the neighbours
  m_detectorManager->initNeighbours();
 
  // Set maximum rows/columns in numerology
  for (int iDesign = 0;  iDesign < m_detectorManager->numDesigns(); iDesign++) {
    m_detectorManager->numerology().setMaxNumPhiCells(m_detectorManager->getPixelDesign(iDesign)->rows());
    m_detectorManager->numerology().setMaxNumEtaCells(m_detectorManager->getPixelDesign(iDesign)->columns());
  }
  
  // Register the callbacks and keys and the level corresponding to the key.
  if (m_geometryManager->Alignable()) {
 
    if (!m_useDynamicAlignFolders){
      m_detectorManager->addAlignFolderType(InDetDD::static_run1);
      m_detectorManager->addFolder("/Indet/Align");
      m_detectorManager->addChannel("/Indet/Align/ID",     2, InDetDD::global);
      m_detectorManager->addChannel("/Indet/Align/PIX",    1, InDetDD::global);
      m_detectorManager->addChannel("/Indet/Align/PIXB1",  0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXB2",  0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXB3",  0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXB4",  0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXEA1", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXEA2", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXEA3", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXEC1", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXEC2", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/Align/PIXEC3", 0, InDetDD::local);
    }
    
    else {
      m_detectorManager->addAlignFolderType(InDetDD::timedependent_run2);
      m_detectorManager->addGlobalFolder("/Indet/AlignL1/ID");
      m_detectorManager->addGlobalFolder("/Indet/AlignL2/PIX");
      m_detectorManager->addChannel("/Indet/AlignL1/ID",     2, InDetDD::global);
      m_detectorManager->addChannel("/Indet/AlignL2/PIX",    1, InDetDD::global);
      m_detectorManager->addFolder("/Indet/AlignL3");
      m_detectorManager->addChannel("/Indet/AlignL3/PIXB1",  0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXB2",  0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXB3",  0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXB4",  0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXEA1", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXEA2", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXEA3", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXEC1", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXEC2", 0, InDetDD::local);
      m_detectorManager->addChannel("/Indet/AlignL3/PIXEC3", 0, InDetDD::local);
    }
 
    // This is the new LB-IOV sensitive IBL bowing DB
    m_detectorManager->addSpecialFolder("/Indet/IBLDist");
 
  }
 
  // Check that there are no missing elements.
  // Bypass checks for standard ATLAS.
  if (m_geometryManager->ibl()) {
    doChecks();
  }
}

detStore() [1/2]

StoreGateSvc * InDetDD::DetectorFactoryBase::detStore ( )

inlineinherited

Definition at line 27 of file InDetDetectorFactoryBase.h.

{return m_athenaComps->detStore();}

detStore() [2/2]

const StoreGateSvc * InDetDD::DetectorFactoryBase::detStore ( ) const

inlineinherited

Definition at line 28 of file InDetDetectorFactoryBase.h.

{return std::as_const(*m_athenaComps).detStore();}

doChecks()

void PixelDetectorFactoryLite::doChecks ( )

private

Definition at line 200 of file PixelDetectorFactoryLite.cxx.

{
  const PixelID * idHelper = m_geometryManager->athenaComps()->getIdHelper();
  const PixelDetectorManager * manager = m_detectorManager;
 
  msg(MSG::INFO) << "Doing consistency checks." << endmsg;
 
  unsigned int maxHash = idHelper->wafer_hash_max();
 
  int count = 0;
  int missingCount = 0;
  InDetDD::SiDetectorElementCollection::const_iterator iter;  
  for (iter = manager->getDetectorElementBegin(); iter != manager->getDetectorElementEnd(); ++iter){
    count++;
    const InDetDD::SiDetectorElement * element = *iter; 
    if (!element) {
      msg(MSG::WARNING) << "MISSING ELEMENT!!!!!!!!!!! - Element # " << count-1 << endmsg;
      missingCount++;
    }
  }
  
  if (missingCount) { 
    msg(MSG::ERROR) << "There are missing elements in element array." << endmsg;
    msg(MSG::INFO) << "Number of elements: " << count << endmsg;
    msg(MSG::INFO) << "Number missing:     " << missingCount << endmsg;
  } 
 
 
  // ***********************************************************************************
  //  Loop over modules
  // ***********************************************************************************
 
  // Barrel
  int barrelCount = 0;
  int barrelCountError = 0;
  for (int iBarrelIndex = 0; iBarrelIndex < manager->numerology().numBarrels(); iBarrelIndex++)
    {
      int iBarrel = manager->numerology().barrelId(iBarrelIndex);
      for (int iLayer = 0; iLayer < manager->numerology().numLayers(); iLayer++) {
            
    // TEMPORARY FIX
    // Temporary fix for IBL. Numerology class needs to be fixed.
    m_geometryManager->SetCurrentLD(iLayer);
    int etaCorrection = 0;
    if (!m_geometryManager->allowSkipEtaZero() && manager->numerology().skipEtaZeroForLayer(iLayer)) {
      etaCorrection = 1;
    }
    // END TEMPORARY FIX
            
    if (manager->numerology().useLayer(iLayer)) {
      for (int iPhi = 0; iPhi < manager->numerology().numPhiModulesForLayer(iLayer); iPhi++)
        {
          for (int iEta = manager->numerology().beginEtaModuleForLayer(iLayer);
           iEta < manager->numerology().endEtaModuleForLayer(iLayer) - etaCorrection;
           iEta++)
        {
          if (!etaCorrection && !iEta && manager->numerology().skipEtaZeroForLayer(iLayer)) continue; // TEMPORARY FIX
          Identifier id = idHelper->wafer_id(iBarrel,iLayer,iPhi,iEta);
          const InDetDD::SiDetectorElement * element = manager->getDetectorElement(id);
          barrelCount++;
          std::stringstream ostr;
          ostr << "[2.1 . " << iBarrel << " . " << iLayer << " . " << iPhi << " . " << iEta << " . 0]";
          if (!element) {
            barrelCountError++;
            msg(MSG::WARNING) << "   No element found for id: " << ostr.str() << " " << idHelper->show_to_string(id) << endmsg;
                            
          }
                        
        } // iEta
                    
        } //iPhi
                
    }
            
      } //iLayer
        
    } // Barrel
 
 
  // Endcap
  int endcapCount = 0;
  int endcapCountError = 0;
  for (int iEndcapIndex = 0; iEndcapIndex < manager->numerology().numEndcaps(); iEndcapIndex++) {
    int iEndcap = manager->numerology().endcapId(iEndcapIndex);
    for (int iDisk = 0; iDisk < manager->numerology().numDisks(); iDisk++) {
      if (manager->numerology().useDisk(iDisk)) { 
    for (int iEta = 0; iEta < manager->numerology().numRingsForDisk(iDisk); iEta++) {
      for (int iPhi = 0; iPhi < manager->numerology().numPhiModulesForDiskRing(iDisk,iEta); iPhi++) {
        Identifier id = idHelper->wafer_id(iEndcap,iDisk,iPhi,iEta);
        const InDetDD::SiDetectorElement * element = manager->getDetectorElement(id);
        endcapCount++;
        std::stringstream ostr;
        ostr << "[2.1." << iEndcap << "." << iDisk << "." << iPhi << "." << iEta << ".0]"; 
        if (!element) {
          endcapCountError++;
          msg(MSG::WARNING) << "    No element found for id: " << ostr.str() << " " << idHelper->show_to_string(id) << endmsg;
        }
      } // iEta
    } //iPhi
      }
    } //iDisk
  } // Endcap;
 
  // Check DBM endcap modules
  int endcapCountDBM = 0;
  int endcapCountErrorDBM = 0;
  if (m_geometryManager->dbm()) {
    // Endcap
    for (int iEndcapIndex = 0; iEndcapIndex < manager->numerology().numEndcapsDBM(); iEndcapIndex++) {
      int iEndcap = manager->numerology().endcapIdDBM(iEndcapIndex);
      for (int iDisk = 0; iDisk < manager->numerology().numDisksDBM(); iDisk++) {
    if (manager->numerology().useDiskDBM(iDisk)) { 
      for (int iEta = 0; iEta < manager->numerology().numRingsForDiskDBM(iDisk); iEta++) {
        for (int iPhi = 0; iPhi < manager->numerology().numPhiModulesForDiskRingDBM(iDisk,iEta); iPhi++) {
          Identifier id = idHelper->wafer_id(iEndcap,iDisk,iPhi,iEta);
          const InDetDD::SiDetectorElement * element = manager->getDetectorElement(id);
          endcapCountDBM++;
          std::stringstream ostr;
          ostr << "[2.1." << iEndcap << "." << iDisk << "." << iPhi << "." << iEta << ".0]"; 
          if (!element) {
        endcapCountErrorDBM++;
        msg(MSG::WARNING) << "    No element found for id (DBM): " << ostr.str() << " " << idHelper->show_to_string(id) << endmsg;
          }
        } // iEta
      } //iPhi
    }
      } //iDisk
    } // Endcap;
  }
  
  if (barrelCountError || endcapCountError || endcapCountErrorDBM) {
    msg(MSG::ERROR) << "There are elements which cannot be found."  << endmsg;
    msg(MSG::INFO) << "Number of barrel elements not found : " << barrelCountError << endmsg;
    msg(MSG::INFO) << "Number of pixel endcap elements not found : " << endcapCountError << endmsg;
    msg(MSG::INFO) << "Number of DBM endcap elements not found : " << endcapCountErrorDBM << endmsg;
  }
 
  if ( barrelCount+endcapCount+endcapCountDBM != int(maxHash)) { 
    msg(MSG::ERROR) << "Total count does not match maxHash." << endmsg;
    msg(MSG::INFO) << "Number of barrel elements       : " << barrelCount << endmsg;
    msg(MSG::INFO) << "Number of endcap elements       : " << endcapCount << endmsg;
    msg(MSG::INFO) << "Number of endcap elements (DBM) : " << endcapCountDBM << endmsg;
    msg(MSG::INFO) << "Total                           : " << barrelCount+endcapCount+endcapCountDBM << endmsg;
    msg(MSG::INFO) << "MaxHash                         : " << maxHash << endmsg;
  }
 
  msg(MSG::INFO) << "Number of barrel elements       : " << barrelCount << endmsg;
  msg(MSG::INFO) << "Number of endcap elements       : " << endcapCount << endmsg;
  msg(MSG::INFO) << "Number of endcap elements (DBM) : " << endcapCountDBM << endmsg;
  msg(MSG::INFO) << "Total                           : " << barrelCount+endcapCount+endcapCountDBM << endmsg;
  msg(MSG::INFO) << "MaxHash                         : " << maxHash << endmsg;
 
}

geoDbTagSvc()

const IGeoDbTagSvc * InDetDD::DetectorFactoryBase::geoDbTagSvc ( ) const

inlineinherited

Definition at line 30 of file InDetDetectorFactoryBase.h.

{return std::as_const(*m_athenaComps).geoDbTagSvc();}

geomDB()

const IGeometryDBSvc * InDetDD::DetectorFactoryBase::geomDB ( ) const

inlineinherited

Definition at line 34 of file InDetDetectorFactoryBase.h.

{return m_athenaComps->geomDB();}

getAthenaComps()

InDetDD::AthenaComps * InDetDD::DetectorFactoryBase::getAthenaComps ( )

inlineinherited

Definition at line 42 of file InDetDetectorFactoryBase.h.

{return m_athenaComps;}

getDetectorManager()

virtual const InDetDD::PixelDetectorManager * PixelDetectorFactoryLite::getDetectorManager ( ) const

inlineoverridevirtual

Definition at line 43 of file PixelDetectorFactoryLite.h.

{ return m_detectorManager; }

msg()

MsgStream & InDetDD::DetectorFactoryBase::msg ( MSG::Level lvl ) const

inlineinherited

Definition at line 37 of file InDetDetectorFactoryBase.h.

{ return m_athenaComps->msg(lvl); }

msgLvl()

bool InDetDD::DetectorFactoryBase::msgLvl ( MSG::Level lvl )

inlineinherited

Definition at line 40 of file InDetDetectorFactoryBase.h.

{ return m_athenaComps->msgLvl(lvl); }

operator=()

const PixelDetectorFactoryLite & PixelDetectorFactoryLite::operator= ( const PixelDetectorFactoryLite & right )

delete

rdbAccessSvc()

IRDBAccessSvc * InDetDD::DetectorFactoryBase::rdbAccessSvc ( )

inlineinherited

Definition at line 32 of file InDetDetectorFactoryBase.h.

{return m_athenaComps->rdbAccessSvc();}

Member Data Documentation

m_athenaComps

InDetDD::AthenaComps* InDetDD::DetectorFactoryBase::m_athenaComps

privateinherited

Definition at line 46 of file InDetDetectorFactoryBase.h.

m_detectorManager

InDetDD::PixelDetectorManager* PixelDetectorFactoryLite::m_detectorManager {nullptr}

private

Definition at line 47 of file PixelDetectorFactoryLite.h.

{nullptr}; //ownership handed to caller

m_geometryManager

std::unique_ptr<PixelGeometryManager> PixelDetectorFactoryLite::m_geometryManager

private

Definition at line 48 of file PixelDetectorFactoryLite.h.

m_mapAX

std::shared_ptr<std::map<std::string, GeoAlignableTransform*> > PixelDetectorFactoryLite::m_mapAX

private

Definition at line 52 of file PixelDetectorFactoryLite.h.

m_mapFPV

std::shared_ptr<std::map<std::string, GeoFullPhysVol*> > PixelDetectorFactoryLite::m_mapFPV

private

Definition at line 51 of file PixelDetectorFactoryLite.h.

m_sqliteReader

GeoModelIO::ReadGeoModel* PixelDetectorFactoryLite::m_sqliteReader {nullptr}

private

Definition at line 46 of file PixelDetectorFactoryLite.h.

{nullptr};

m_useDynamicAlignFolders

bool PixelDetectorFactoryLite::m_useDynamicAlignFolders {false}

private

Definition at line 50 of file PixelDetectorFactoryLite.h.

{false};

---

The documentation for this class was generated from the following files:

• PixelDetectorFactoryLite.h
• PixelDetectorFactoryLite.cxx