#include <OccupancyMapMaker.h>

Inheritance diagram for OccupancyMapMaker:

Collaboration diagram for OccupancyMapMaker:

Public Member Functions
	OccupancyMapMaker (const std::string &name, ISvcLocator *pSvcLocator)

	~OccupancyMapMaker ()

StatusCode	initialize ()

StatusCode	execute ()

StatusCode	finalize ()

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

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

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::string	getDCSIDFromPosition (int bec, int layer, int modPhi, int modEta)

std::vector< std::string > &	splitter (const std::string &str, char delim, std::vector< std::string > &elems)

std::vector< std::string >	splitter (const std::string &str, char delim)

StatusCode	registerHistograms ()

const std::string	histoSuffix (const int bec, const int layer)

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ServiceHandle< ITHistSvc >	m_tHistSvc

ToolHandle< IInDetConditionsTool >	m_pixelConditionsTool {this, "PixelConditionsSummaryTool", "PixelConditionsSummaryTool", "Tool to retrieve Pixel Conditions summary"}

const PixelID *	m_pixelID

std::vector< std::pair< std::string, std::vector< int > > >	m_pixelMapping

std::string	m_pixelRDOKey

std::vector< int >	m_moduleHashList

double	m_nEvents

TH1D *	m_nEventsHist

TH1D *	m_nEventsLBHist

std::vector< TH2D * >	m_hitMaps

std::vector< TH2C * >	m_noiseMaps

std::vector< TH1D * >	m_LBdependence

std::vector< TH1D * >	m_BCIDdependence

std::vector< TH1D * >	m_TOTdistributions

TH1D *	m_disabledModules

TH2D *	m_overlayedPixelNoiseMap

TH2D *	m_overlayedIBLDCNoiseMap

TH2D *	m_overlayedIBLSCNoiseMap

double	m_disk1ACut

double	m_disk2ACut

double	m_disk3ACut

double	m_disk1CCut

double	m_disk2CCut

double	m_disk3CCut

double	m_iblCut

double	m_bLayerCut

double	m_layer1Cut

double	m_layer2Cut

double	m_dbmCut

int	m_hist_lbMax

double	m_longPixelMultiplier

double	m_gangedPixelMultiplier

bool	m_occupancyPerBC

unsigned int	m_nBCReadout

unsigned int	m_evt_lbMin

unsigned int	m_evt_lbMax

bool	m_calculateNoiseMaps

std::string	m_mapFile

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 25 of file OccupancyMapMaker.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ OccupancyMapMaker()

OccupancyMapMaker::OccupancyMapMaker	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 33 of file OccupancyMapMaker.cxx.

                                                                                     :
   AthAlgorithm(name, pSvcLocator),
   m_tHistSvc("THistSvc", name),
   m_pixelID(0),
   m_pixelRDOKey("PixelRDOs"),
   m_nEvents(0.),
   m_nEventsHist(nullptr),
   m_nEventsLBHist(nullptr),
   m_disabledModules(nullptr),
   m_overlayedPixelNoiseMap(nullptr),
   m_overlayedIBLDCNoiseMap(nullptr),
   m_overlayedIBLSCNoiseMap(nullptr),
   m_disk1ACut(1.e-3),
   m_disk2ACut(1.e-3),
   m_disk3ACut(1.e-3),
   m_disk1CCut(1.e-3),
   m_disk2CCut(1.e-3),
   m_disk3CCut(1.e-3),
   m_iblCut(1.e-3), 
   m_bLayerCut(1.e-3),
   m_layer1Cut(1.e-3),
   m_layer2Cut(1.e-3),
   m_dbmCut(1.e-3),
   m_hist_lbMax(3001),
   m_longPixelMultiplier(1.5), 
   m_gangedPixelMultiplier(2.), 
   m_occupancyPerBC(true),
   m_nBCReadout(2),
   m_evt_lbMin(0),
   m_evt_lbMax(-1),
   m_calculateNoiseMaps(false),
   m_mapFile("PixelMapping_Run2.dat")
 {
   declareProperty("PixelRDOKey", m_pixelRDOKey, "StoreGate key of pixel RDOs");
   declareProperty("Disk1ACut", m_disk1ACut, "Occupancy cut for Disk1A pixels");
   declareProperty("Disk2ACut", m_disk2ACut, "Occupancy cut for Disk2A pixels");
   declareProperty("Disk3ACut", m_disk3ACut, "Occupancy cut for Disk3A pixels");
   declareProperty("Disk1CCut", m_disk1CCut, "Occupancy cut for Disk1C pixels");
   declareProperty("Disk2CCut", m_disk2CCut, "Occupancy cut for Disk2C pixels");
   declareProperty("Disk3CCut", m_disk3CCut, "Occupancy cut for Disk3C pixels");
   declareProperty("BLayerCut", m_bLayerCut, "Occupancy cut for BLayer pixels");
   declareProperty("Layer1Cut", m_layer1Cut, "Occupancy cut for Layer1 pixels");
   declareProperty("Layer2Cut", m_layer2Cut, "Occupancy cut for Layer2 pixels");
   declareProperty("IBLCut", m_dbmCut, "Occupancy cut for DBM pixels"); 
   declareProperty("nLBmax", m_hist_lbMax, "Maximum number of LB (for histograms binning)");
   declareProperty("NBCReadout", m_nBCReadout, "Number of bunch crossings read out");
   declareProperty("LBMin", m_evt_lbMin, "First lumi block to consider");
   declareProperty("LBMax", m_evt_lbMax, "Last lumi block to consider");
   declareProperty("LongPixelMultiplier", m_longPixelMultiplier, "Multiplier for long pixels");
   declareProperty("GangedPixelMultiplier", m_gangedPixelMultiplier, "Multiplier for ganged pixels");
   declareProperty("OccupancyPerBC", m_occupancyPerBC, "Calculate occupancy per BC or per event");
   declareProperty("CalculateNoiseMaps", m_calculateNoiseMaps, "If false only build hit maps");
   declareProperty("InputPixelMap", m_mapFile);
   declareProperty("THistSvc", m_tHistSvc, "THistSvc");
 }

◆ ~OccupancyMapMaker()

OccupancyMapMaker::~OccupancyMapMaker ( )

Definition at line 89 of file OccupancyMapMaker.cxx.

89 {}

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode OccupancyMapMaker::execute ( )

Definition at line 299 of file OccupancyMapMaker.cxx.

                                      {
   ATH_MSG_DEBUG( "Executing OccupancyMapMaker" );
  
   const EventContext& ctx = Gaudi::Hive::currentContext();
  
   // check LB is in allowed range
   unsigned int LB =  ctx.eventID().lumi_block();
   if( (LB < m_evt_lbMin) || (m_evt_lbMax >= m_evt_lbMin && LB > m_evt_lbMax) ){
     ATH_MSG_VERBOSE("Event in lumiblock " << LB <<
             " not in selected range [" << m_evt_lbMin << "," << m_evt_lbMax << "] => skipped");    
     return StatusCode::SUCCESS;
   }
  
   // retrieve PixelRDO container
   const PixelRDO_Container* pixelRDOs = nullptr;
   StatusCode sc = evtStore()->retrieve(pixelRDOs, m_pixelRDOKey);
   if( !sc.isSuccess() ){
     ATH_MSG_FATAL( "Unable to retrieve pixel RDO container at " << m_pixelRDOKey );
     return StatusCode::FAILURE;
   } ATH_MSG_DEBUG( "Pixel RDO container retrieved" );
  
   // loop in RDO container
   for(PixelRDO_Container::const_iterator coll=pixelRDOs->begin(); 
       coll!=pixelRDOs->end(); ++coll){
  
     const InDetRawDataCollection<PixelRDORawData>* PixelRDOCollection(*coll);
     if(PixelRDOCollection != 0){
       Identifier moduleID = PixelRDOCollection->identify();
       IdentifierHash modHash = m_pixelID->wafer_hash(moduleID);
       ATH_MSG_VERBOSE("moduleID, modHash = " << moduleID << " , " << modHash);
       
       // exclude module if reported as not good by PixelConditionsSummaryTool
       if( !(m_pixelConditionsTool->isGood(modHash, ctx)) ) {
     ATH_MSG_VERBOSE("Module excluded as reported not good by PixelConditionsSummaryTool");
         continue;
       }
  
       // exclude module if containg FE synch errors
       if (m_pixelConditionsTool->hasBSError(modHash, ctx)) {
     ATH_MSG_VERBOSE("Module excluded as containing FE synch errors");
     continue;
       }
       
       for(DataVector<PixelRDORawData>::const_iterator rdo = PixelRDOCollection->begin();
           rdo!=PixelRDOCollection->end(); ++rdo){
         Identifier rdoID = (*rdo)->identify();
         unsigned int pixel_eta = m_pixelID->eta_index(rdoID);
         unsigned int pixel_phi = m_pixelID->phi_index(rdoID);
  
         int TOT = (*rdo)->getToT(); // it returns a 8 bits "word"
         int BCID = (*rdo)->getBCID();
  
         m_hitMaps[modHash]->Fill(pixel_eta, pixel_phi);
         m_LBdependence[modHash]->Fill(LB);
         m_BCIDdependence[modHash]->Fill(BCID);
         m_TOTdistributions[modHash]->Fill(TOT);
       }
     }
   }
  
  
   // [sgs] why is this done in every event ???
   for(unsigned int moduleHash = 0; moduleHash < m_pixelID->wafer_hash_max(); moduleHash++) {
     if( !m_pixelConditionsTool->isActive( moduleHash, ctx ) ){
       m_disabledModules->Fill( moduleHash );
     }
   }
   
   m_nEvents++;
   m_nEventsHist->Fill(0.5);
   m_nEventsLBHist->Fill(LB);
  
   return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

 {
   // If we didn't find any symlinks to add, just return the collection
   // from the base class.  Otherwise, return the extended collection.
   if (!m_extendedExtraObjects.empty()) {
     return m_extendedExtraObjects;
   }
   return Algorithm::extraOutputDeps();
 }

◆ finalize()

StatusCode OccupancyMapMaker::finalize ( )

Definition at line 380 of file OccupancyMapMaker.cxx.

                                        {
   ATH_MSG_INFO("Finalizing OccupancyMapMaker");
  
   if(m_occupancyPerBC)
     m_nEvents *= m_nBCReadout;
  
   const int minLogOccupancy = 8;
   const double minOccupancy = pow(10.,-minLogOccupancy);
   
   TH1D* globalOccupancy= new TH1D("occupancy", "Pixel occupancy", minLogOccupancy*10, -minLogOccupancy, 0.);
   m_tHistSvc->regHist("/histfile/occupancy",globalOccupancy).ignore();
  
   std::map<std::string, TH1D*> h_occupancy;
  
   // occupancy histograms for different components of the Pixel detector
   std::vector<std::string> vcomponent;
   vcomponent.push_back("Disk1A");
   vcomponent.push_back("Disk2A");
   vcomponent.push_back("Disk3A");
   vcomponent.push_back("Disk1C");
   vcomponent.push_back("Disk2C");
   vcomponent.push_back("Disk3C");
   vcomponent.push_back("IBL"); 
   vcomponent.push_back("B-layer");
   vcomponent.push_back("Layer1");
   vcomponent.push_back("Layer2");
   vcomponent.push_back("DBMA");
   vcomponent.push_back("DBMC");
  
   for(std::vector<std::string>::const_iterator cit=vcomponent.begin(); cit!=vcomponent.end(); ++cit) {
     const std::string comp = (*cit);
     h_occupancy[comp] = new TH1D( ("occupancy"+comp).c_str(), ("Pixel occupancy "+comp).c_str(),
                   minLogOccupancy*10, -minLogOccupancy, 0);    
     m_tHistSvc->regHist(("/histfile/occupancy"+comp).c_str(), h_occupancy[comp]).ignore();
   }
   vcomponent.clear();
   
   // occupancy histograms for different pixel types
   std::vector<std::string> vtype;
   vtype.push_back("Normal");
   vtype.push_back("Ganged");
   vtype.push_back("InterGanged");
   vtype.push_back("Long");
   vtype.push_back("Long-Ganged");
   vtype.push_back("Long-InterGanged");
  for(std::vector<std::string>::const_iterator cit=vtype.begin(); cit!=vtype.end(); ++cit){
     const std::string type = (*cit);
     h_occupancy[type] = 
       new TH1D( ("occupancy"+type).c_str(), ("Pixel occupancy "+type).c_str(), 
         minLogOccupancy*10, -minLogOccupancy, 0);
     m_tHistSvc->regHist(("/histfile/occupancy"+type).c_str(), h_occupancy[type]).ignore();
   }
   vtype.clear();
  
   //------------------------
   // number of hits 
   //------------------------  
  
   // IBL
   TH2F* nhitsPlotBI=new TH2F("nhitsPlotBI", "Number of hits BI;module_eta;module_phi", 20, -10, 10, 14, -0.5, 13.5); 
   m_tHistSvc->regHist("/histfile/nhitsPlotBI",nhitsPlotBI).ignore();
  
   // B-layer
   TH2F* nhitsPlotB0=new TH2F("nhitsPlotB0", "Number of hits B0;module_eta;module_phi", 13, -6.5, 6.5, 22, -0.5, 21.5);
   m_tHistSvc->regHist("/histfile/nhitsPlotB0",nhitsPlotB0).ignore();
  
   // barrel layer 1
   TH2F* nhitsPlotB1=new TH2F("nhitsPlotB1", "Number of hits B1;module_eta;module_phi", 13, -6.5, 6.5, 38, -0.5, 37.5);
   m_tHistSvc->regHist("/histfile/nhitsPlotB1",nhitsPlotB1).ignore();
  
   // barrel layer 2
   TH2F* nhitsPlotB2=new TH2F("nhitsPlotB2", "Number of hits B2;module_eta;module_phi", 13,- 6.5, 6.5, 52, -0.5, 51.5);
   m_tHistSvc->regHist("/histfile/nhitsPlotB2",nhitsPlotB2).ignore();
  
   // endcap
   TH2F* nhitsPlotEC=new TH2F("nhitsPlotEC", "Number of hits Endcap;Disk;module_phi", 7, -3.5, 3.5, 48, -0.5, 47.5);
   m_tHistSvc->regHist("/histfile/nhitsPlotEC",nhitsPlotEC).ignore();
   
   // DBM
   TH2F* nhitsPlotDBM=new TH2F("nhitsPlotDBM", "Number of hits DBM;Layer;module_phi",7,-3.5,3.5,4,-0.5,3.5);
   m_tHistSvc->regHist("/histfile/nhitsPlotDBM",nhitsPlotDBM).ignore();
  
   //------------------------
   // hits w/o noise
   //------------------------  
  
   // IBL
   TH2F* nhitsNoNoisePlotBI=new TH2F("nhitsNoNoisePlotBI","Number of hits without Noise BI;module_eta;module_phi", 20, -10, 10, 14, -0.5, 13.5); 
   m_tHistSvc->regHist("/histfile/nhitsNoNoisePlotBI",nhitsNoNoisePlotBI).ignore();
  
   // B-layer
   TH2F* nhitsNoNoisePlotB0=new TH2F("nhitsNoNoisePlotB0","Number of hits without Noise B0;module_eta;module_phi", 13, -6.5, 6.5, 22, -0.5, 21.5);
   m_tHistSvc->regHist("/histfile/nhitsNoNoisePlotB0",nhitsNoNoisePlotB0).ignore();
  
   // barrel layer 1
   TH2F* nhitsNoNoisePlotB1=new TH2F("nhitsNoNoisePlotB1","Number of hits without Noise B1;module_eta;module_phi", 13, -6.5, 6.5, 38, -0.5, 37.5);
   m_tHistSvc->regHist("/histfile/nhitsNoNoisePlotB1",nhitsNoNoisePlotB1).ignore();
  
   // barrel layer 2
   TH2F* nhitsNoNoisePlotB2=new TH2F("nhitsNoNoisePlotB2","Number of hits without Noise B2;module_eta;module_phi", 13, -6.5, 6.5, 52, -0.5, 51.5);
   m_tHistSvc->regHist("/histfile/nhitsNoNoisePlotB2",nhitsNoNoisePlotB2).ignore();
  
   //------------------------
   // disabled pixels
   //------------------------  
  
   // IBL
   TH2F* disablePlotBI=new TH2F("disablePlotBI", "Disabled pixels BI;module_eta;module_phi", 20, -10, 10, 14, -0.5, 13.5); 
   m_tHistSvc->regHist("/histfile/disablePlotBI",disablePlotBI).ignore();
  
   // B-layer
   TH2F* disablePlotB0=new TH2F("disablePlotB0", "Disabled pixels B0;module_eta;module_phi", 13,- 6.5, 6.5, 22, -0.5, 21.5);
   m_tHistSvc->regHist("/histfile/disablePlotB0",disablePlotB0).ignore();
  
   // barrel layer 1
   TH2F* disablePlotB1=new TH2F("disablePlotB1", "Disabled pixels B1;module_eta;module_phi", 13, -6.5, 6.5, 38, -0.5, 37.5);
   m_tHistSvc->regHist("/histfile/disablePlotB1",disablePlotB1).ignore();
  
   // barrel layer 2
   TH2F* disablePlotB2=new TH2F("disablePlotB2", "Disabled pixels B2;module_eta;module_phi", 13, -6.5, 6.5, 52, -0.5, 51.5);
   m_tHistSvc->regHist("/histfile/disablePlotB2",disablePlotB2).ignore();
  
   // endcap
   TH2F* disablePlotEC=new TH2F("disablePlotEC", "Disabled pixels Endcap;Disk;module_phi", 7, -3.5, 3.5, 48, -0.5, 47.5);
   m_tHistSvc->regHist("/histfile/disablePlotEC",disablePlotEC).ignore();
  
   // DBM
   TH2F* disablePlotDBM=new TH2F("disablePlotDBM", "Disabled pixels DBM;Layer;module_phi", 7, -3.5, 3.5, 4, -0.5, 3.5);
   m_tHistSvc->regHist("/histfile/disablePlotDBM",disablePlotDBM).ignore();
  
   TH1D* maskedPlot= new TH1D("maskedPlot","Disabled pixel per module",50,0.5,50.5);
   m_tHistSvc->regHist("/histfile/maskedPlot",maskedPlot).ignore();
  
   int totalDisabledPixels=0;
   int totalDisabledModules=0;
   int modulesWithHits=0;
   int modulesWithDisabledPixels=0;
  
   const EventContext& ctx{Gaudi::Hive::currentContext()};
   for (PixelID::const_id_iterator wafer_it=m_pixelID->wafer_begin(); wafer_it!=m_pixelID->wafer_end(); ++wafer_it) {
     Identifier ident = *wafer_it;
     if(!m_pixelID->is_pixel(ident)) continue;  
  
     int bec     = m_pixelID->barrel_ec (ident);
     int layer   = m_pixelID->layer_disk(ident);
     int modPhi  = m_pixelID->phi_module(ident);
     int modEta  = m_pixelID->eta_module(ident); 
     int modHash = m_pixelID->wafer_hash(ident);
     int phi_max = m_pixelID->phi_index_max(ident);
     int eta_max = m_pixelID->eta_index_max(ident);
  
     TH2F* nhitsNoNoisePlot=0; 
     std::string comp;
     double cut = 0.;
  
     if(bec != 0) { // Disk or DBM
       if(bec == 2) { 
         if(layer == 0)      {cut=m_disk1ACut; comp="Disk1A"; }
         else if(layer == 1) {cut=m_disk2ACut; comp="Disk2A"; }
         else if(layer == 2) {cut=m_disk3ACut; comp="Disk3A"; }
       }
       else if(bec == -2) { 
         if(layer == 0)      { cut=m_disk1CCut; comp="Disk1C"; }
         else if(layer == 1) { cut=m_disk2CCut; comp="Disk2C"; }
         else if(layer == 2) { cut=m_disk3CCut; comp="Disk3C"; }
       }
       else if(bec ==  4) { cut=m_dbmCut; comp="DBMA"; }
       else if(bec == -4) { cut=m_dbmCut; comp="DBMC"; }
     } 
     else if(bec == 0) { // Barrel
       if(layer == 0)        { cut=m_iblCut;    nhitsNoNoisePlot=nhitsNoNoisePlotBI; comp="IBL";     }
         else if(layer == 1) { cut=m_bLayerCut; nhitsNoNoisePlot=nhitsNoNoisePlotB0; comp="B-layer"; }
         else if(layer == 2) { cut=m_layer1Cut; nhitsNoNoisePlot=nhitsNoNoisePlotB1; comp="Layer1";  }
         else if(layer == 3) { cut=m_layer2Cut; nhitsNoNoisePlot=nhitsNoNoisePlotB2; comp="Layer2";  }
     } 
  
     if (!m_pixelConditionsTool->hasBSError(modHash, ctx) && m_hitMaps[modHash]->GetEntries()==0) {
       if(bec == 0) {
     if(layer == 0)      { disablePlotBI->Fill(modEta, modPhi, -1); }
     else if(layer == 1) { disablePlotB0->Fill(modEta, modPhi, -1); }
     else if(layer == 2) { disablePlotB1->Fill(modEta, modPhi, -1); }
     else if(layer == 3) { disablePlotB2->Fill(modEta, modPhi, -1); }
       }
       else if(bec ==  2) { disablePlotEC->Fill(layer+1,     modPhi, -1); }
       else if(bec == -2) { disablePlotEC->Fill(-(layer+1),  modPhi, -1); }
       else if(bec ==  4) { disablePlotDBM->Fill(layer+1,    modPhi, -1); }
       else if(bec == -4) { disablePlotDBM->Fill(-(layer+1), modPhi, -1); }
  
       totalDisabledModules++;
       continue;
     }
     else if( m_hitMaps[modHash]->GetEntries() != 0 ) {
       if(bec == 0) {
     if(layer == 0)      { nhitsPlotBI->Fill(modEta, modPhi, m_hitMaps[modHash]->GetEntries()); }
     else if(layer == 1) { nhitsPlotB0->Fill(modEta, modPhi, m_hitMaps[modHash]->GetEntries()); }
     else if(layer == 2) { nhitsPlotB1->Fill(modEta, modPhi, m_hitMaps[modHash]->GetEntries()); }
     else if(layer == 3) { nhitsPlotB2->Fill(modEta, modPhi, m_hitMaps[modHash]->GetEntries()); }
       }
       else if(bec ==  2) { nhitsPlotEC->Fill(layer+1,     modPhi, m_hitMaps[modHash]->GetEntries()); }
       else if(bec == -2) { nhitsPlotEC->Fill(-(layer+1),  modPhi, m_hitMaps[modHash]->GetEntries()); }
       else if(bec ==  4) { nhitsPlotDBM->Fill(layer+1,    modPhi, m_hitMaps[modHash]->GetEntries()); }
       else if(bec == -4) { nhitsPlotDBM->Fill(-(layer+1), modPhi, m_hitMaps[modHash]->GetEntries()); }
  
       modulesWithHits++;
     }
  
     int thisModuleCut = 0;
     bool isIBL3D = ( bec==0 && layer==0 && (modEta <= -7 || modEta >= 6) ) ? true : false;
  
     for(int pixel_eta=0; pixel_eta<=eta_max; pixel_eta++){
       for(int pixel_phi=0; pixel_phi<=phi_max; pixel_phi++){
  
         // kazuki added from here
         int pixel_eta_on_chip = (bec==0 && layer==0) ? pixel_eta % 80 : pixel_eta % 18; // column
         int pixel_phi_on_chip = (pixel_phi <= 163) ? pixel_phi : 327 - pixel_phi; // eta
         if (bec == 0 && layer == 0) pixel_phi_on_chip = pixel_phi;
         int pixelType = 0;
  
         if (bec == 0 && layer == 0) { // ----- IBL ----- //
           if( !isIBL3D && (pixel_eta_on_chip == 0 || pixel_eta_on_chip == 80 - 1) ){
             pixelType = 1; // long
           }
           else { // pixel size = 50x250 um2
             pixelType = 0; // normal
           }
         } else { // Pixel
           if(pixel_eta_on_chip > 0 && pixel_eta_on_chip < 18 - 1){ // pixel size = 50x400 um2
             pixelType = 0; // normal
             for(int kk = 0; kk < 3; kk++){
               // row 154,156,158                       = inter-ganged
               // row 153,155,157,159,  160,161,162,163 = ganged
               if(pixel_phi_on_chip == (153 + 2 * kk + 1)){
                 pixelType = 5; // inter-ganged (dealt as normal)
                 break;
               }
               if(pixel_phi_on_chip == (153 + 2 * kk) || pixel_phi_on_chip >= 159){
                 pixelType = 2; // ganged
                 break;
               }
             }
           }
           else if(pixel_eta_on_chip == 0 || pixel_eta_on_chip == 18 - 1){
             pixelType =  1; //long
             for(int kk = 0; kk < 3; kk++){
               if(pixel_phi_on_chip == (153 + 2 * kk + 1)){
                 pixelType = 6; // long inter-ganged (dealt as long)
                 break;
               }
               if(pixel_phi_on_chip == (153 + 2 * kk) || pixel_phi_on_chip >= 159){
                 pixelType = 3; // long ganged
                 break;
               }
             }
           }
           else
             pixelType =  8; //invalid pixel_phi/pixel_eta pair
         }
         // to here
  
         std::string type;
  
  
         switch(pixelType) {
           case 0:
             type = "Normal";
             break;
           case 1:
             type = "Long";
             break;
           case 2:
             type = "Ganged";
             break;
           case 3:
             type = "Long-Ganged";
             break;
           case 5:
             type = "Long-InterGanged";
             break;
           case 6:
             type = "InterGanged";
             break;
           case 8:
           default:
             type = "Invalid";
             break;
         }
  
         double thiscut = cut;
         if( type == "Ganged" )                thiscut *= m_gangedPixelMultiplier;
         else if( type == "Long" )             thiscut *= m_longPixelMultiplier;
         else if( type == "Long-InterGanged" ) thiscut *= m_longPixelMultiplier;
         else if( type == "Long-Ganged" )      thiscut *= m_longPixelMultiplier * m_gangedPixelMultiplier;
  
         if( type != "Invalid" ){
       double occupancy = 0;
       if( m_nEvents != 0 ) 
         occupancy = static_cast<double>(m_hitMaps[modHash]->GetBinContent(pixel_eta+1, pixel_phi+1)) /
           static_cast<double>(m_nEvents);
       
           if( occupancy < minOccupancy ) occupancy = minOccupancy;
           globalOccupancy->Fill(log10(occupancy));
           h_occupancy[comp]->Fill(log10(occupancy));
           h_occupancy[type]->Fill(log10(occupancy));
  
           if( occupancy > thiscut ) {
             thisModuleCut++;
  
             if( m_calculateNoiseMaps ){
               m_noiseMaps[modHash]->Fill(pixel_eta, pixel_phi);
               if (comp == "IBL") {
                 if(modEta >= -6 && modEta <= 5) m_overlayedIBLDCNoiseMap->Fill(pixel_eta, pixel_phi); // Planar
                 if(modEta <= -7 || modEta >= 6) m_overlayedIBLSCNoiseMap->Fill(pixel_eta, pixel_phi); // 3D
               }
               else m_overlayedPixelNoiseMap->Fill(pixel_eta, pixel_phi);
             }
           } else {
             if(bec == 0) nhitsNoNoisePlot->Fill(modEta, modPhi, m_hitMaps[modHash]->GetBinContent(pixel_eta+1, pixel_phi+1));
           }
         } // end if ( type != "Invalid" )
       } // end for loop on pixel_phi
     } // end for loop on pixel_eta
  
     if ( thisModuleCut > 0 ) {
       totalDisabledPixels+=thisModuleCut;
       maskedPlot->Fill( static_cast<double>(thisModuleCut) );
       modulesWithDisabledPixels++;
    
       if(bec == 0) {
     if(layer == 0)      { disablePlotBI->Fill(modEta, modPhi, thisModuleCut); }
     else if(layer == 1) { disablePlotB0->Fill(modEta, modPhi, thisModuleCut); }
     else if(layer == 2) { disablePlotB1->Fill(modEta, modPhi, thisModuleCut); }
     else if(layer == 3) { disablePlotB2->Fill(modEta, modPhi, thisModuleCut); }
       }
       else if(bec ==  2) { disablePlotEC->Fill(layer+1,    modPhi, thisModuleCut); }
       else if(bec == -2) { disablePlotEC->Fill(-(layer+1), modPhi, thisModuleCut); }
     }
   } // end loop in detector elements
   
   ATH_MSG_INFO("Modules disabled = " << totalDisabledModules);
   ATH_MSG_INFO("Modules with hits = " << modulesWithHits);
   ATH_MSG_INFO("Modules with disabled pixels = " << modulesWithDisabledPixels);
   ATH_MSG_INFO("Total disabled pixels = " << totalDisabledPixels);
  
   return StatusCode::SUCCESS;
   
 } // end finalize

◆ getDCSIDFromPosition()

std::string OccupancyMapMaker::getDCSIDFromPosition	(	int	bec,
		int	layer,
		int	modPhi,
		int	modEta
	)

private

Definition at line 111 of file OccupancyMapMaker.cxx.

                                                                                                       {
   for(unsigned int ii = 0; ii < m_pixelMapping.size(); ii++) {
     if (m_pixelMapping[ii].second.size() != 4) {
       ATH_MSG_WARNING( "getDCSIDFromPosition: Vector size is not 4!" );
       return std::string("Error!");
     }
     if (m_pixelMapping[ii].second[0] != barrel_ec) continue;
     if (m_pixelMapping[ii].second[1] != layer) continue;
     if (m_pixelMapping[ii].second[2] != modPhi) continue;
     if (m_pixelMapping[ii].second[3] != module_eta) continue;
     return m_pixelMapping[ii].first;
   }
   ATH_MSG_WARNING( "Not found!" );
   return std::string("Error!");
 }

◆ histoSuffix()

const std::string OccupancyMapMaker::histoSuffix	(	const int	bec,
		const int	layer
	)

private

Definition at line 127 of file OccupancyMapMaker.cxx.

                                                                             {
   std::ostringstream out;
   
   switch(bec) {
   case 0: 
     out << "barrel/";  
     if(layer==0)      { out << "IBL";              }
     else if(layer==1) { out << "B-layer";          }
     else              { out << "Layer" << layer-1; }
     break;
   case +2: out << "endcapA/Disk" << layer+1; break;
   case -2: out << "endcapC/Disk" << layer+1; break;
   case +4: out << "DBMA/Layer"   << layer+1; break;
   case -4: out << "DBMC/Layer"   << layer+1; break;
   default: break;
   }  
   return out.str();
 }

◆ initialize()

StatusCode OccupancyMapMaker::initialize ( )

Definition at line 91 of file OccupancyMapMaker.cxx.

                                         {
   ATH_MSG_INFO("Initializing OccupancyMapMaker");
  
   ATH_CHECK(m_tHistSvc.retrieve());
   ATH_CHECK(m_pixelConditionsTool.retrieve());
   ATH_CHECK(detStore()->retrieve(m_pixelID, "PixelID"));
  
   // resize vectors of histograms
   const Identifier::size_type maxHash = m_pixelID->wafer_hash_max();
   ATH_MSG_INFO("PixelID maxHash = " << maxHash);
   m_hitMaps.resize(maxHash);
   m_LBdependence.resize(maxHash);
   m_BCIDdependence.resize(maxHash);
   m_TOTdistributions.resize(maxHash);
   if(m_calculateNoiseMaps) {
     m_noiseMaps.resize(maxHash);
   }
   return registerHistograms(); 
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ registerHistograms()

StatusCode OccupancyMapMaker::registerHistograms ( )

private

Definition at line 164 of file OccupancyMapMaker.cxx.

                                                 {
  
   char* getenvPath = std::getenv("DATAPATH");
   const unsigned int maxPathStringLength{3000};
   if((not getenvPath) or (strlen(getenvPath) > maxPathStringLength) ){
       ATH_MSG_FATAL( "Unable to retrieve environmental DATAPATH" );
       return StatusCode::FAILURE;
   }
   std::stringstream tmpSstr{};
   tmpSstr<<getenvPath;
   std::string tmppath(tmpSstr.str());
  
   std::vector<std::string> paths = splitter(tmppath, ':'); 
   bool found(false);  
   for(const auto& x : paths){
     std::ifstream infile( (x+"/"+m_mapFile).c_str() );
     if( infile.is_open() ){
       ATH_MSG_INFO("Mapping file '" << m_mapFile << "' found in " << x);
  
       int tmp_barrel_ec; int tmp_layer; int tmp_modPhi; int tmp_module_eta; std::string tmp_module_name;
       std::vector<int> tmp_position;
       tmp_position.resize(4);
       while(infile >> tmp_barrel_ec >> tmp_layer >> tmp_modPhi >> tmp_module_eta >> tmp_module_name) {
         tmp_position[0] = tmp_barrel_ec;
         tmp_position[1] = tmp_layer;
         tmp_position[2] = tmp_modPhi;
         tmp_position[3] = tmp_module_eta;
         m_pixelMapping.push_back(std::make_pair(tmp_module_name, tmp_position));
       }
  
       found=true;
       infile.close();
       break;
     }
   }
   
   if( !found ){
     ATH_MSG_FATAL("Mapping file '" << m_mapFile << "' not found in DATAPATH !!!");
     return StatusCode::FAILURE;
   }
  
   m_nEventsHist = new TH1D("NEvents", "NEvents", 1, 0, 1);
   m_tHistSvc->regHist("/histfile/NEvents", m_nEventsHist).ignore();
   
   m_nEventsLBHist = new TH1D("NEventsLB", "NEventsLB", m_hist_lbMax, -0.5, m_hist_lbMax+0.5);
   m_tHistSvc->regHist("/histfile/NEventsLB", m_nEventsLBHist).ignore();
  
   for (PixelID::const_id_iterator wafer_it=m_pixelID->wafer_begin(); wafer_it!=m_pixelID->wafer_end(); ++wafer_it) {
     Identifier ident = *wafer_it;
     if(!m_pixelID->is_pixel(ident)) continue; 
     
     //const InDetDD::PixelModuleDesign* design = dynamic_cast<const InDetDD::PixelModuleDesign*>(&element->design());
     //if(!design) continue;    
     //unsigned int mchips = design->numberOfCircuits();
  
     int bec        = m_pixelID->barrel_ec(ident);
     int layer      = m_pixelID->layer_disk(ident); 
     int modPhi = m_pixelID->phi_module(ident);
     int module_eta = m_pixelID->eta_module(ident); 
     int modHash = m_pixelID->wafer_hash(ident);
  
     std::string onlineID = 
       getDCSIDFromPosition(bec,layer,modPhi,module_eta);
  
     std::ostringstream name;
     
     // hitmap
     if( bec == 0 && layer == 0) // IBL
       m_hitMaps[modHash] = new TH2D(onlineID.c_str(), onlineID.c_str(), 160, 0, 160, 336, 0, 336);
     else if( abs(bec) == 4 ) // DBM
       m_hitMaps[modHash] = new TH2D(onlineID.c_str(), onlineID.c_str(), 80,  0,  80, 336, 0, 336);
     else
       m_hitMaps[modHash] = new TH2D(onlineID.c_str(), onlineID.c_str(), 144, 0, 144, 328, 0, 328);    
     name << "/histfile/hitMaps_" << histoSuffix(bec,layer) << "/" << onlineID;
     m_tHistSvc->regHist(name.str().c_str(), m_hitMaps[modHash]).ignore();
     name.str(""); name.clear();
  
  
     // LB dependence
     m_LBdependence[modHash] = new TH1D(onlineID.c_str(), onlineID.c_str(), m_hist_lbMax, -0.5, m_hist_lbMax + 0.5);
     name  << "/histfile/LBdep_" << histoSuffix(bec,layer) << "/" << onlineID;
     m_tHistSvc->regHist(name.str().c_str(), m_LBdependence[modHash]).ignore();
     name.str(""); name.clear();
     
     // BCID dependence
     m_BCIDdependence[modHash] = new TH1D(onlineID.c_str(), onlineID.c_str(), 301, -0.5, 300.5);
     name << "/histfile/BCIDdep_" << histoSuffix(bec,layer) << "/" << onlineID;
     m_tHistSvc->regHist(name.str().c_str(), m_BCIDdependence[modHash]).ignore();
     name.str(""); name.clear();
     
     // TOT
     if( bec == 0 && layer == 0) // IBL
       m_TOTdistributions[modHash] = new TH1D(onlineID.c_str(), onlineID.c_str(), 19, -0.5, 18.5);
     else
       m_TOTdistributions[modHash] = new TH1D(onlineID.c_str(), onlineID.c_str(), 256, -0.5, 255.5);
     name << "/histfile/TOT_" << histoSuffix(bec,layer) << "/" << onlineID;
     m_tHistSvc->regHist(name.str().c_str(), m_TOTdistributions[modHash]).ignore();
     name.str(""); name.clear();
     
     // noisemap
     if( m_calculateNoiseMaps ){
       if( bec == 0 && layer == 0) // IBL
     m_noiseMaps[modHash] = new TH2C(onlineID.c_str(), onlineID.c_str(), 160, 0, 160, 336, 0, 336);
       else if( abs(bec) == 4 ) // DBM
     m_noiseMaps[modHash] = new TH2C(onlineID.c_str(), onlineID.c_str(), 80, 0, 80, 336, 0, 336);
       else
     m_noiseMaps[modHash] = new TH2C(onlineID.c_str(), onlineID.c_str(), 144, 0, 144, 328, 0, 328);
       name << "/histfile/noiseMaps_" << histoSuffix(bec,layer) << "/" << onlineID;
       m_tHistSvc->regHist(name.str().c_str(), m_noiseMaps[modHash]).ignore();
       name.str(""); name.clear();
     }
   } // end loop in detector elements 
   
   m_disabledModules = new TH1D("DisabledModules", "Number of events disabled vs. IdentifierHash", 2048, 0, 2048);
   m_tHistSvc->regHist("/histfile/DisabledModules", m_disabledModules).ignore();
   
   if (m_calculateNoiseMaps) {
     m_overlayedPixelNoiseMap = new TH2D("overlayedPixelNoiseMap", "Noisy pixel map overlayed all Pixel modules", 144, 0, 144, 328, 0, 328);
     m_tHistSvc->regHist("/histfile/overlayedPixelNoiseMap", m_overlayedPixelNoiseMap).ignore();
     
     m_overlayedIBLDCNoiseMap = new TH2D("overlayedIBLDCNoiseMap", "Noisy pixel map overlayed all IBL Planar modules", 160, 0, 160, 336, 0, 336);
     m_tHistSvc->regHist("/histfile/overlayedIBLDCNoiseMap", m_overlayedIBLDCNoiseMap).ignore();
     
     m_overlayedIBLSCNoiseMap = new TH2D("overlayedIBLSCNoiseMap", "Noisy pixel map overlayed all IBL 3D modules", 80, 0, 80, 336, 0, 336);
     m_tHistSvc->regHist("/histfile/overlayedIBLSCNoiseMap", m_overlayedIBLSCNoiseMap).ignore();
   }  
   
   return StatusCode::SUCCESS;
 } 

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ splitter() [1/2]

std::vector< std::string > OccupancyMapMaker::splitter	(	const std::string &	str,
		char	delim
	)

private

Definition at line 157 of file OccupancyMapMaker.cxx.

                                        {
   std::vector<std::string> elems;
   splitter(str, delim, elems);
   return elems;
 }

◆ splitter() [2/2]

std::vector< std::string > & OccupancyMapMaker::splitter	(	const std::string &	str,
		char	delim,
		std::vector< std::string > &	elems
	)

private

Definition at line 146 of file OccupancyMapMaker.cxx.

                                                          {
   std::stringstream ss(str);
   std::string item;
   while (std::getline(ss, item, delim)) {
     elems.push_back(item);
   }
   return elems;
 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                        {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
  
   if (sc.isFailure()) {
     return sc;
   }
   ServiceHandle<ICondSvc> cs("CondSvc",name());
   for (auto h : outputHandles()) {
     if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
       // do this inside the loop so we don't create the CondSvc until needed
       if ( cs.retrieve().isFailure() ) {
         ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
         return StatusCode::SUCCESS;
       }
       if (cs->regHandle(this,*h).isFailure()) {
         sc = StatusCode::FAILURE;
         ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                       << " with CondSvc");
       }
     }
   }
   return sc;
 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

Member Data Documentation

◆ m_BCIDdependence

std::vector<TH1D*> OccupancyMapMaker::m_BCIDdependence

private

Definition at line 66 of file OccupancyMapMaker.h.

◆ m_bLayerCut

double OccupancyMapMaker::m_bLayerCut

private

Definition at line 83 of file OccupancyMapMaker.h.

◆ m_calculateNoiseMaps

bool OccupancyMapMaker::m_calculateNoiseMaps

private

Definition at line 102 of file OccupancyMapMaker.h.

◆ m_dbmCut

double OccupancyMapMaker::m_dbmCut

private

Definition at line 86 of file OccupancyMapMaker.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_disabledModules

TH1D* OccupancyMapMaker::m_disabledModules

private

Definition at line 69 of file OccupancyMapMaker.h.

◆ m_disk1ACut

double OccupancyMapMaker::m_disk1ACut

private

Definition at line 76 of file OccupancyMapMaker.h.

◆ m_disk1CCut

double OccupancyMapMaker::m_disk1CCut

private

Definition at line 79 of file OccupancyMapMaker.h.

◆ m_disk2ACut

double OccupancyMapMaker::m_disk2ACut

private

Definition at line 77 of file OccupancyMapMaker.h.

◆ m_disk2CCut

double OccupancyMapMaker::m_disk2CCut

private

Definition at line 80 of file OccupancyMapMaker.h.

◆ m_disk3ACut

double OccupancyMapMaker::m_disk3ACut

private

Definition at line 78 of file OccupancyMapMaker.h.

◆ m_disk3CCut

double OccupancyMapMaker::m_disk3CCut

private

Definition at line 81 of file OccupancyMapMaker.h.

◆ m_evt_lbMax

unsigned int OccupancyMapMaker::m_evt_lbMax

private

Definition at line 100 of file OccupancyMapMaker.h.

◆ m_evt_lbMin

unsigned int OccupancyMapMaker::m_evt_lbMin

private

Definition at line 99 of file OccupancyMapMaker.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_gangedPixelMultiplier

double OccupancyMapMaker::m_gangedPixelMultiplier

private

Definition at line 91 of file OccupancyMapMaker.h.

◆ m_hist_lbMax

int OccupancyMapMaker::m_hist_lbMax

private

Definition at line 88 of file OccupancyMapMaker.h.

◆ m_hitMaps

std::vector<TH2D*> OccupancyMapMaker::m_hitMaps

private

Definition at line 63 of file OccupancyMapMaker.h.

◆ m_iblCut

double OccupancyMapMaker::m_iblCut

private

Definition at line 82 of file OccupancyMapMaker.h.

◆ m_layer1Cut

double OccupancyMapMaker::m_layer1Cut

private

Definition at line 84 of file OccupancyMapMaker.h.

◆ m_layer2Cut

double OccupancyMapMaker::m_layer2Cut

private

Definition at line 85 of file OccupancyMapMaker.h.

◆ m_LBdependence

std::vector<TH1D*> OccupancyMapMaker::m_LBdependence

private

Definition at line 65 of file OccupancyMapMaker.h.

◆ m_longPixelMultiplier

double OccupancyMapMaker::m_longPixelMultiplier

private

Definition at line 90 of file OccupancyMapMaker.h.

◆ m_mapFile

std::string OccupancyMapMaker::m_mapFile

private

Definition at line 104 of file OccupancyMapMaker.h.

◆ m_moduleHashList

std::vector<int> OccupancyMapMaker::m_moduleHashList

private

Definition at line 56 of file OccupancyMapMaker.h.

◆ m_nBCReadout

unsigned int OccupancyMapMaker::m_nBCReadout

private

Definition at line 97 of file OccupancyMapMaker.h.

◆ m_nEvents

double OccupancyMapMaker::m_nEvents

private

Definition at line 58 of file OccupancyMapMaker.h.

◆ m_nEventsHist

TH1D* OccupancyMapMaker::m_nEventsHist

private

Definition at line 61 of file OccupancyMapMaker.h.

◆ m_nEventsLBHist

TH1D* OccupancyMapMaker::m_nEventsLBHist

private

Definition at line 62 of file OccupancyMapMaker.h.

◆ m_noiseMaps

std::vector<TH2C*> OccupancyMapMaker::m_noiseMaps

private

Definition at line 64 of file OccupancyMapMaker.h.

◆ m_occupancyPerBC

bool OccupancyMapMaker::m_occupancyPerBC

private

Definition at line 95 of file OccupancyMapMaker.h.

◆ m_overlayedIBLDCNoiseMap

TH2D* OccupancyMapMaker::m_overlayedIBLDCNoiseMap

private

Definition at line 71 of file OccupancyMapMaker.h.

◆ m_overlayedIBLSCNoiseMap

TH2D* OccupancyMapMaker::m_overlayedIBLSCNoiseMap

private

Definition at line 72 of file OccupancyMapMaker.h.

◆ m_overlayedPixelNoiseMap

TH2D* OccupancyMapMaker::m_overlayedPixelNoiseMap

private

Definition at line 70 of file OccupancyMapMaker.h.

◆ m_pixelConditionsTool

ToolHandle<IInDetConditionsTool> OccupancyMapMaker::m_pixelConditionsTool {this, "PixelConditionsSummaryTool", "PixelConditionsSummaryTool", "Tool to retrieve Pixel Conditions summary"}

private

Definition at line 47 of file OccupancyMapMaker.h.

◆ m_pixelID

const PixelID* OccupancyMapMaker::m_pixelID

private

Definition at line 50 of file OccupancyMapMaker.h.

◆ m_pixelMapping

std::vector< std::pair< std::string, std::vector<int> > > OccupancyMapMaker::m_pixelMapping

private

Definition at line 53 of file OccupancyMapMaker.h.

◆ m_pixelRDOKey

std::string OccupancyMapMaker::m_pixelRDOKey

private

Definition at line 55 of file OccupancyMapMaker.h.

◆ m_tHistSvc

ServiceHandle<ITHistSvc> OccupancyMapMaker::m_tHistSvc

private

Definition at line 45 of file OccupancyMapMaker.h.

◆ m_TOTdistributions

std::vector<TH1D*> OccupancyMapMaker::m_TOTdistributions

private

Definition at line 67 of file OccupancyMapMaker.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ OccupancyMapMaker()

◆ ~OccupancyMapMaker()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ getDCSIDFromPosition()

◆ histoSuffix()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ registerHistograms()

◆ renounce()

◆ renounceArray()

◆ splitter() [1/2]

◆ splitter() [2/2]

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_BCIDdependence

◆ m_bLayerCut

◆ m_calculateNoiseMaps

◆ m_dbmCut

◆ m_detStore

◆ m_disabledModules

◆ m_disk1ACut

◆ m_disk1CCut

◆ m_disk2ACut

◆ m_disk2CCut

◆ m_disk3ACut

◆ m_disk3CCut

◆ m_evt_lbMax

◆ m_evt_lbMin

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_gangedPixelMultiplier

◆ m_hist_lbMax

◆ m_hitMaps

◆ m_iblCut

◆ m_layer1Cut

◆ m_layer2Cut

◆ m_LBdependence

◆ m_longPixelMultiplier

◆ m_mapFile

◆ m_moduleHashList

◆ m_nBCReadout

◆ m_nEvents

◆ m_nEventsHist

◆ m_nEventsLBHist

◆ m_noiseMaps

◆ m_occupancyPerBC

◆ m_overlayedIBLDCNoiseMap

◆ m_overlayedIBLSCNoiseMap