#include <HitMapBuilder.h>

Inheritance diagram for HitMapBuilder:

Collaboration diagram for HitMapBuilder:

Public Member Functions
	~HitMapBuilder ()

StatusCode	initialize ()

StatusCode	execute ()

StatusCode	finalize ()

	AthAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters: More...

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 {this, "THistSvc", "THistSvc/THistSvc"}

SG::ReadHandleKey< PixelRDO_Container >	m_pixelRDOKey {this,"PixelRDOKey","PixelRDOs","StoreGate Key of Pixel RDOs"}

const InDetDD::PixelDetectorManager *	m_pixman =nullptr

const PixelID *	m_pixelID =nullptr

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

double	m_nEvents =0

std::vector< double >	m_nEventsLB

std::vector< double >	m_nEventsLBCategory

std::unique_ptr< TH1F >	m_nEventsHist

std::unique_ptr< TH1F >	m_nEventsLBHist

std::vector< std::unique_ptr< TH2F > >	m_occupancyMaps

std::vector< std::unique_ptr< TH2F > >	m_occupancyMapsIBL2dLB

std::vector< std::unique_ptr< TH1F > >	m_TOTdistributions

std::vector< std::unique_ptr< TH1F > >	m_TOTdistributionsIBL2dLB

std::vector< std::unique_ptr< TH1F > >	m_occupancyLB

Gaudi::Property< int >	m_hist_lbMax {this,"nLBmax", 3001, "Maximum number of LB (for histograms binning)"}

Gaudi::Property< int >	m_evt_lbMin {this,"LBMin",0,"First lumi block to consider"}

Gaudi::Property< int >	m_evt_lbMax {this,"LBMax",-1,"Last lumi block to consider"}

int	m_LBrange_max = -9999

const unsigned int	m_nIblFes = 14 * (4 + 62) 2

const int	m_perLB_min =0

const int	m_perLB_max =3000

const int	m_perLB_step =100

const int	m_perLB_n = (m_perLB_max-m_perLB_min)/m_perLB_step

const int	m_fei4bPixels = 26880

const int	m_pixModPixels = 46080

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

HitMapBuilder.h.

Creates hit maps and maps of noisy pixels for every module of the pixel detector. The maps are stored in a root file. They can be written to the conditions database using the algorithm NoiseMapDBWriter.

ruwie.nosp@m.del@.nosp@m.physi.nosp@m.k.un.nosp@m.i-bon.nosp@m.n.de

Definition at line 46 of file HitMapBuilder.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

◆ ~HitMapBuilder()

HitMapBuilder::~HitMapBuilder ( )

Definition at line 24 of file HitMapBuilder.cxx.

24 {

25 }

Member Function Documentation

◆ AthAlgorithm()

AthAlgorithm::AthAlgorithm

Constructor with parameters:

Definition at line 51 of file AthAlgorithm.cxx.

                                                        :
   ::AthCommonDataStore<AthCommonMsg<Algorithm>>   ( name, pSvcLocator )
 {
   // Set up to run AthAlgorithmDHUpdate in sysInitialize before
   // merging dependency lists.  This extends the output dependency
   // list with any symlinks implied by inheritance relations.
   m_updateDataHandles =
     std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
     (m_extendedExtraObjects,
      std::move (m_updateDataHandles));
 }

◆ 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 HitMapBuilder::execute ( )

Definition at line 334 of file HitMapBuilder.cxx.

                                   {
   ATH_MSG_DEBUG( "Executing HitMapBuilder" );
  
   const EventContext& ctx = Gaudi::Hive::currentContext();
  
   // check LB is in allowed range
   int LB =  static_cast<int>(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;
   }
  
   // Get max LB range
   if (m_LBrange_max < LB) m_LBrange_max = LB;
  
 // retrieve PixelRDO container
   SG::ReadHandle<PixelRDO_Container> pixelRDOs{m_pixelRDOKey,ctx};
   ATH_MSG_DEBUG( "Pixel RDO container retrieved" );
   // loop in RDO container
   for (const auto pPixelRDOCollection: *pixelRDOs) {
     if (pPixelRDOCollection) {
       Identifier moduleID = pPixelRDOCollection->identify();
       IdentifierHash modHash = m_pixelID->wafer_hash(moduleID);
       ATH_MSG_VERBOSE("moduleID, modHash = " << moduleID << " , " << modHash);
  
       for (DataVector<PixelRDORawData>::const_iterator rdo=pPixelRDOCollection->begin(); rdo!=pPixelRDOCollection->end(); ++rdo) {
         Identifier rdoID = (*rdo)->identify();
         int bec       = m_pixelID->barrel_ec(rdoID);
         //
         if (std::abs(bec) == 4) continue; // Skip DBM
         //
         unsigned int pixel_eta = m_pixelID->eta_index(rdoID);
         unsigned int pixel_phi = m_pixelID->phi_index(rdoID);
         int layer     = m_pixelID->layer_disk(rdoID);
         int modPhi    = m_pixelID->phi_module(rdoID);
         int modEta    = m_pixelID->eta_module(rdoID);
         const Identifier::size_type maxHash = m_pixelID->wafer_hash_max();
  
         
  
         int iblFeHash = -99;
         if (bec==0 && layer==0) { // IBL FE order: {0..3}: 3D C, {4..15}: 2D C, {16..27}: 2D A, {28..31}: 3D A
           if (modEta <= -7)                 iblFeHash = modPhi*32 + (modEta+10); // 3D C
           else if (-6<=modEta && modEta<=5) iblFeHash = modPhi*32 + ((modEta+6)*2+4); // 2D
           else                              iblFeHash = modPhi*32 + (modEta+22); // 3D A
           if (pixel_eta/80) iblFeHash++; // For 2D, C side '_1', or A side '_2' for pixel_eta 80~159
         }
  
         int TOT = (*rdo)->getToT(); // it returns a 8 bits "word"
   
         // Category: All
         if (bec == 0 && layer == 0 && -6 <= modEta && modEta <= 5) { // IBL 2D
           int ibl2dHash = maxHash + iblFeHash;
           m_occupancyMaps[ibl2dHash]->Fill(pixel_eta%80, pixel_phi);
           m_occupancyLB[ibl2dHash]->Fill(LB);
           m_TOTdistributions[ibl2dHash]->Fill(TOT);
         }
         else { // None IBL 2D
           m_occupancyMaps[modHash]->Fill(pixel_eta, pixel_phi);
           m_occupancyLB[modHash]->Fill(LB);
           m_TOTdistributions[modHash]->Fill(TOT);
         }
  
         // Category: LB
         if (0 <= iblFeHash) { // IBL
           for (int i=0; i<m_perLB_n; i++) {
             if ((m_perLB_min+m_perLB_step*i < LB) && (LB <= m_perLB_min+m_perLB_step*(i+1))) { // LB
               int ibl2dHash = m_nIblFes*i + iblFeHash;
               m_occupancyMapsIBL2dLB[ibl2dHash]->Fill(pixel_eta%80, pixel_phi);
               m_TOTdistributionsIBL2dLB[ibl2dHash]->Fill(TOT);
             }
           }
         }
       }
     }
   }
   m_nEvents++;
   m_nEventsHist->Fill(0.5);
   m_nEventsLBHist->Fill(LB);
  
   m_nEventsLB[LB]++;
   m_nEventsLBCategory[(LB-m_perLB_min)/m_perLB_step]++;
  
   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 HitMapBuilder::finalize ( )

Definition at line 425 of file HitMapBuilder.cxx.

                                    {
   ATH_MSG_INFO("Finalizing HitMapBuilder");
  
   ATH_CHECK(m_tHistSvc->regHist("/histfile/NEvents", std::move(m_nEventsHist)));
   ATH_CHECK(m_tHistSvc->regHist("/histfile/NEventsLB", std::move(m_nEventsLBHist)));
  
   //
   // loop in detector elements
   //
   for (InDetDD::SiDetectorElementCollection::const_iterator iter=m_pixman->getDetectorElementBegin(); iter!=m_pixman->getDetectorElementEnd(); ++iter) {
     const InDetDD::SiDetectorElement* element = *iter;
     if (element == 0) continue;
  
     Identifier ident = element->identify();
     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);
     const Identifier::size_type maxHash = m_pixelID->wafer_hash_max();
  
     if (abs(bec) == 4) continue; // Skip DBM
  
     int iblFeHash = -99;
     if (bec==0 && layer==0) { // IBL FE order: {0..3}: 3D C, {4..15}: 2D C, {16..27}: 2D A, {28..31}: 3D A
       if (modEta <= -7)                 iblFeHash = modPhi*32 + (modEta+10); // 3D C
       else if (-6<=modEta && modEta<=5) iblFeHash = modPhi*32 + ((modEta+6)*2+4); // 2D
       else                              iblFeHash = modPhi*32 + (modEta+22); // 3D A
     }
  
     // Divide by events for Occupancy Map
     // Category: All
     if (bec == 0 && layer == 0 && -6 <= modEta && modEta <= 5) { // IBL 2D
       int ibl2dHash = maxHash + iblFeHash;
       for (int chipId=0; chipId<2; chipId++) { // 2 Fes in double module
         //yosuke m_occupancyMaps[ibl2dHash+chipId]->Scale(1.0/(m_nEvents));
         // Occupancy LB
         int entries = m_occupancyLB[ibl2dHash+chipId]->GetEntries();
         for (int lb=0; lb<m_hist_lbMax; lb++) {
           if (m_nEventsLB[lb] == 0) continue;
           m_occupancyLB[ibl2dHash+chipId]->SetBinContent(lb+1, m_occupancyLB[ibl2dHash+chipId]->GetBinContent(lb+1)/(m_nEventsLB[lb]*m_fei4bPixels)); // Also divide by fei4 pixels
         }
         m_occupancyLB[ibl2dHash+chipId]->SetEntries(entries);
         m_occupancyLB[ibl2dHash+chipId]->SetBins(m_LBrange_max+100, -0.5, m_LBrange_max+99.5);
       }
     }
     else { // None IBL 2D
       //yosuke m_occupancyMaps[modHash]->Scale(1.0/(m_nEvents));
       // Occupancy LB
       int entries = m_occupancyLB[modHash]->GetEntries();
       for (int lb=0; lb<m_hist_lbMax; lb++) {
         if (m_nEventsLB[lb] == 0) continue;
         if (0 <= iblFeHash) m_occupancyLB[modHash]->SetBinContent(lb+1, m_occupancyLB[modHash]->GetBinContent(lb+1)/(m_nEventsLB[lb]*m_fei4bPixels)); // IBL 3D, divide by fei4 pixels
         else m_occupancyLB[modHash]->SetBinContent(lb+1, m_occupancyLB[modHash]->GetBinContent(lb+1)/(m_nEventsLB[lb]*m_pixModPixels)); // Pixel module, divide by pixel module pixels
       }
       m_occupancyLB[modHash]->SetEntries(entries);
       m_occupancyLB[modHash]->SetBins(m_LBrange_max+100, -0.5, m_LBrange_max+99.5);
     }
  
     std::string onlineID = getDCSIDFromPosition(bec,layer,modPhi,modEta);
  
     std::ostringstream name;
     std::string axisTitle;
  
     // Construct IBL Planar later
     std::string LBCategory;
     std::string occ2dDir = "Occupancy2d";
     std::string occLBDir = "OccupancyLb";
     std::string totDir = "ToT";
  
     // Category: All
     LBCategory = "All";
     if (bec == 0 && layer == 0 && -6 <= modEta && modEta <= 5) { // IBL 2D
       for (unsigned chipId=0; chipId<=1; chipId++) { // FE chips in double module
         int ibl2dHash;
         if (chipId) {
           if (modEta <= -1) ibl2dHash = maxHash + iblFeHash; // C side, '_2'
           else ibl2dHash = maxHash + iblFeHash + chipId; // A side, '_2'
         }
         else {
           if (modEta <= -1) ibl2dHash = maxHash + iblFeHash + 1; // C side, '_1'
           else ibl2dHash = maxHash + iblFeHash; // A side, '_1'
         }
         // Occupancy Map
         axisTitle = ";pixel_eta;pixel_phi;# hits/pixel/event";
         name << "/histfile/" << LBCategory << "/" << occ2dDir << "/" << histoSuffix(bec,layer) << "/" << onlineID << "_" << chipId+1;
         ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_occupancyMaps[ibl2dHash])));
         name.str(""); name.clear();
  
         // Occupancy vs. LB
         axisTitle = ";LB;# hits/pixel/event";
         name << "/histfile/" << LBCategory << "/" << occLBDir << "/" << histoSuffix(bec,layer) << "/" << onlineID << "_" << chipId+1;
         ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_occupancyLB[ibl2dHash])));
         name.str(""); name.clear();
  
         // ToT
         axisTitle = ";ToT;# hits";
         name << "/histfile/" << LBCategory << "/" << totDir << "/" << histoSuffix(bec,layer) << "/" << onlineID << "_" << chipId+1;
         ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_TOTdistributions[ibl2dHash])));
         name.str(""); name.clear();
       }
     }
     else { // None IBL 2D
       // Occupancy Map
       axisTitle = ";pixel_eta;pixel_phi;# hits/pixel/event";
       name << "/histfile/" << LBCategory << "/" << occ2dDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
       ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_occupancyMaps[modHash])));
       name.str(""); name.clear();
  
       // Occupancy vs. LB
       axisTitle = ";LB;# hits/pixel/event";
       name << "/histfile/" << LBCategory << "/" << occLBDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
       ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_occupancyLB[modHash])));
       name.str(""); name.clear();
  
       // ToT
       axisTitle = ";ToT;# hits";
       name << "/histfile/" << LBCategory << "/" << totDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
       ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_TOTdistributions[modHash])));
       name.str(""); name.clear();
     } // End of if ibl 2d
  
     // Category: LB1-100, 101-200, ...
     if (0 <= iblFeHash) { // IBL
       for (int i=0; i<m_perLB_n; i++) {
         LBCategory = "LB" + std::to_string(m_perLB_min+m_perLB_step*i+1) + "-" + std::to_string(m_perLB_min+m_perLB_step*(i+1));
         if (-6 <= modEta && modEta <= 5) { // IBL 2D
           for (int chipId=0; chipId<=1; chipId++) { // FE chips in double module
             int ibl2dHash;
             if (chipId) {
               if (modEta <= -1) ibl2dHash = m_nIblFes*i + iblFeHash; // C side, '_2'
               else ibl2dHash = m_nIblFes*i + iblFeHash + chipId; // A side, '_2'
             }
             else {
               if (modEta <= -1) ibl2dHash = m_nIblFes*i + iblFeHash + 1; // C side, '_1'
               else ibl2dHash = m_nIblFes*i + iblFeHash; // A side, '_1'
             }
             std::string histTitle = onlineID + "_" + std::to_string(chipId+1);
             // Occupancy Map
             axisTitle = ";pixel_eta;pixel_phi;# hits/pixel/event";
             name << "/histfile/" << LBCategory << "/" << occ2dDir << "/" << histoSuffix(bec,layer) << "/" << histTitle;
             ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_occupancyMapsIBL2dLB[ibl2dHash])));
             name.str(""); name.clear();
  
             // ToT
             axisTitle = ";ToT;# hits";
             name << "/histfile/" << LBCategory << "/" << totDir << "/" << histoSuffix(bec,layer) << "/" << histTitle;
             ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_TOTdistributionsIBL2dLB[ibl2dHash])));
             name.str(""); name.clear();
           }
         }
         else { // IBL 3D
           int ibl2dHash = m_nIblFes*i + iblFeHash;
           // Occupancy Map
           axisTitle = ";pixel_eta;pixel_phi;# hits/pixel/event";
           name << "/histfile/" << LBCategory << "/" << occ2dDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
           ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_occupancyMapsIBL2dLB[ibl2dHash])));
           name.str(""); name.clear();
  
           // ToT
           axisTitle = ";ToT;# hits";
           name << "/histfile/" << LBCategory << "/" << totDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
           ATH_CHECK(m_tHistSvc->regHist(name.str(), std::move(m_TOTdistributionsIBL2dLB[ibl2dHash])));
           name.str(""); name.clear();
         } // End of if ibl 2d
       } // End of loop of category: LB
     } // End of if IBL
   }  // end loop in detector elements
  
   return StatusCode::SUCCESS;
  
 } // end finalize

◆ getDCSIDFromPosition()

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

private

Definition at line 27 of file HitMapBuilder.cxx.

                                                                                                   {
   for (unsigned int ii = 0; ii < m_pixelMapping.size(); ii++) {
     if (m_pixelMapping[ii].second.size() != 4) {
       ATH_MSG_FATAL("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_FATAL("DCS ID is not found!");
   return std::string("Error!");
 }

◆ histoSuffix()

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

private

Definition at line 43 of file HitMapBuilder.cxx.

                                                                          {
   std::ostringstream out;
   switch (bec) {
     case 0:
       if (layer==0)  out << "IBL";
       else          out << "B" << layer-1;
       break;
     case +2: out << "Disk" << layer+1 << "A"; break;
     case -2: out << "Disk" << layer+1 << "C"; break;
     case +4: out << "DBM"  << layer+1 << "A"; break;
     case -4: out << "DBM"  << layer+1 << "C"; break;
     default: break;
   }
   return out.str();
 }

◆ initialize()

StatusCode HitMapBuilder::initialize ( )

Definition at line 79 of file HitMapBuilder.cxx.

                                      {
   ATH_MSG_INFO("Initializing HitMapBuilder");
  
   ATH_CHECK(m_pixelRDOKey.initialize());
  
   // retrieve THistSvc
   StatusCode sc = m_tHistSvc.retrieve();
   if (!sc.isSuccess()) {
     ATH_MSG_FATAL("Unable to retrieve THistSvc");
     return StatusCode::FAILURE;
   }
   // retrieve PixelDetectorManager
   sc = detStore()->retrieve(m_pixman,"Pixel");
   if (!sc.isSuccess()) {
     ATH_MSG_FATAL("Unable to retrieve PixelDetectorManager");
     return StatusCode::FAILURE;
   }
  
   // retrieve PixelID helper
   sc = detStore()->retrieve(m_pixelID, "PixelID");
   if (!sc.isSuccess()) {
     ATH_MSG_FATAL("Unable to retrieve PixelID helper");
     return StatusCode::FAILURE;
   }
  
   // resize vectors of histograms
   const Identifier::size_type maxHash = m_pixelID->wafer_hash_max();
   ATH_MSG_DEBUG("PixelID maxHash = " << maxHash);
   m_occupancyMaps.resize(maxHash+m_nIblFes);
   m_occupancyMapsIBL2dLB.resize(m_perLB_n*m_nIblFes);
   m_TOTdistributions.resize(maxHash+m_nIblFes);
   m_TOTdistributionsIBL2dLB.resize(m_perLB_n*m_nIblFes);
   m_occupancyLB.resize(maxHash+m_nIblFes);
  
   // Resize vector of variables
   m_nEventsLB.resize(m_hist_lbMax);
   m_nEventsLBCategory.resize(m_perLB_n);
  
   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 HitMapBuilder::registerHistograms ( )

private

Definition at line 121 of file HitMapBuilder.cxx.

                                              {
   const std::string mapFile = "PixelMapping_Run2.dat";
  
   std::vector<std::string> paths = splitter(std::getenv("DATAPATH"), ':');
   bool found(false);
   for (const auto& x : paths) {
     std::ifstream infile((x+"/"+mapFile).c_str());
     if (infile.is_open()) {
       ATH_MSG_INFO("Mapping file '" << 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 '" << mapFile << "' not found in DATAPATH !!!");
     return StatusCode::FAILURE;
   }
  
   // Register event histogram
   m_nEventsHist = std::make_unique<TH1F>("NEvents", "NEvents;;# events", 1, 0, 1);
   m_nEventsLBHist = std::make_unique<TH1F>("NEventsLB", "NEventsLB;LB;# events", m_hist_lbMax, -0.5, m_hist_lbMax+0.5);
  
   // Regist TDirectory first
   // HARD CODING, TODO do in a smarter way
   std::vector<std::pair<int, int>> temp_bec_layer{std::make_pair(2, 3), std::make_pair(-2, 3), std::make_pair(0, 4)};
   std::vector<std::string> temp_dir{"Occupancy2d", "OccupancyLb", "ToT"};
   for (auto const& bl : temp_bec_layer) {
     for (int l=0; l<bl.second; l++) {
       for (auto const& d: temp_dir) {
         std::string temp_str = "/histfile/All/" + d + "/" + histoSuffix(bl.first, l) + "/" + d + histoSuffix(bl.first, l);
         std::unique_ptr<TH1F>temp_h1d = std::make_unique<TH1F>((d+histoSuffix(bl.first, l)).c_str(), (d+histoSuffix(bl.first, l)).c_str(), 1, 0, 1);
         ATH_CHECK(m_tHistSvc->regHist(temp_str.c_str(), std::move(temp_h1d)));
         ATH_CHECK(m_tHistSvc->deReg(temp_str));
       }
     }
   }
  
   for (InDetDD::SiDetectorElementCollection::const_iterator iter=m_pixman->getDetectorElementBegin(); iter!=m_pixman->getDetectorElementEnd(); ++iter) {
     const InDetDD::SiDetectorElement* element = *iter;
     if (!element) continue;
  
     Identifier ident = element->identify();
     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);
     const Identifier::size_type maxHash = m_pixelID->wafer_hash_max();
  
     if (abs(bec) == 4) continue; // Skip DBM
  
     int iblFeHash = -99;
     // Use special fe chip index for IBL
     // {0..3}: 3D C, C8_2, C8_1, C7_2, C7_1
     // {4..15}: 2D C, C6_2, C6_1, ..., C1_2, C1_1
     // {16..27}: 2D A, A1_1, A1_2, ..., A6_1, A6_2
     // {28..31}: 3D A, A7_1, A7_2, A8_1, A8_2
     if (bec == 0 && layer == 0) {
       if (modEta <= -7)                 iblFeHash = modPhi*32 + (modEta+10); // 3D C
       else if (-6<=modEta && modEta<=5) iblFeHash = modPhi*32 + ((modEta+6)*2+4); // 2D
       else                              iblFeHash = modPhi*32 + (modEta+22); // 3D A
       // iblFeHash, here, is even
     }
  
     std::string onlineID = getDCSIDFromPosition(bec,layer,modPhi,modEta);
  
     std::ostringstream name;
     std::string axisTitle;
  
     // Construct IBL Planar later
     std::string LBCategory;
     std::string occ2dDir = "Occupancy2d";
     std::string occLBDir = "OccupancyLb";
     std::string totDir = "ToT";
  
     // Category: All
     LBCategory = "All";
     if (bec == 0 && layer == 0 && -6 <= modEta && modEta <= 5) { // IBL 2D
       for (unsigned chipId=0; chipId<=1; chipId++) { // FE chips in double module
         int ibl2dHash;
         if (chipId) {
           if (modEta <= -1) ibl2dHash = maxHash + iblFeHash; // C side, '_2'
           else ibl2dHash = maxHash + iblFeHash + chipId; // A side, '_2'
         }
         else {
           if (modEta <= -1) ibl2dHash = maxHash + iblFeHash + 1; // C side, '_1'
           else ibl2dHash = maxHash + iblFeHash; // A side, '_1'
         }
         std::string histTitle = onlineID + "_" + std::to_string(chipId+1);
         // Occupancy Map
         axisTitle = ";pixel_eta;pixel_phi;# hits/pixel/event";
         m_occupancyMaps[ibl2dHash] = std::make_unique<TH2F>(histTitle.c_str(), (histTitle+axisTitle).c_str(), 80, -0.5, 79.5, 336, -0.5, 335.5);
         name << "/histfile/" << LBCategory << "/" << occ2dDir << "/" << histoSuffix(bec,layer) << "/" << onlineID << "_" << chipId+1;
         name.str(""); name.clear();
         m_occupancyMaps[ibl2dHash]->SetOption("colz");
  
         // Occupancy vs. LB
         axisTitle = ";LB;# hits/pixel/event";
         m_occupancyLB[ibl2dHash] = std::make_unique<TH1F>(histTitle.c_str(), (histTitle+axisTitle).c_str(), m_hist_lbMax, -0.5, m_hist_lbMax-0.5);
         name << "/histfile/" << LBCategory << "/" << occLBDir << "/" << histoSuffix(bec,layer) << "/" << onlineID << "_" << chipId+1;
         name.str(""); name.clear();
  
         // ToT
         axisTitle = ";ToT;# hits";
         m_TOTdistributions[ibl2dHash] = std::make_unique<TH1F>(histTitle.c_str(), (histTitle+axisTitle).c_str(), 19, -0.5, 18.5);
         name << "/histfile/" << LBCategory << "/" << totDir << "/" << histoSuffix(bec,layer) << "/" << onlineID << "_" << chipId+1;
         name.str(""); name.clear();
       }
     }
     else { // None IBL 2D
       // Occupancy Map
       axisTitle = ";pixel_eta;pixel_phi;# hits/pixel/event";
       if (bec == 0 && layer == 0) {
         m_occupancyMaps[modHash] = std::make_unique<TH2F>(onlineID.c_str(), (onlineID+axisTitle).c_str(),  80, -0.5,  79.5, 336, -0.5, 335.5); // IBL 3D
       }
       else {
         m_occupancyMaps[modHash] = std::make_unique<TH2F>(onlineID.c_str(), (onlineID+axisTitle).c_str(), 144, -0.5, 143.5, 328, -0.5, 327.5);
       }
       name << "/histfile/" << LBCategory << "/" << occ2dDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
       name.str(""); name.clear();
       m_occupancyMaps[modHash].get()->SetOption("colz");
  
       // Occupancy vs. LB
       axisTitle = ";LB;# hits/pixel/event";
       m_occupancyLB[modHash] = std::make_unique<TH1F>(onlineID.c_str(), (onlineID+axisTitle).c_str(), m_hist_lbMax, -0.5, m_hist_lbMax-0.5);
       name << "/histfile/" << LBCategory << "/" << occLBDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
       name.str(""); name.clear();
  
       // ToT
       axisTitle = ";ToT;# hits";
       if (bec == 0 && layer == 0) {
         m_TOTdistributions[modHash] = std::make_unique<TH1F>(onlineID.c_str(), (onlineID+axisTitle).c_str(),  19, -0.5,  18.5); // IBL 3D
       }
       else {
         m_TOTdistributions[modHash] = std::make_unique<TH1F>(onlineID.c_str(), (onlineID+axisTitle).c_str(), 256, -0.5, 255.5);
       }
       name << "/histfile/" << LBCategory << "/" << totDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
       name.str(""); name.clear();
     } // End of if ibl 2d
  
     // Category: LB1-100, 101-200, ...
     if (0 <= iblFeHash) { // IBL
       for (int i=0; i<m_perLB_n; i++) {
         LBCategory = "LB" + std::to_string(m_perLB_min+m_perLB_step*i+1) + "-" + std::to_string(m_perLB_min+m_perLB_step*(i+1));
         if (-6 <= modEta && modEta <= 5) { // IBL 2D
           for (int chipId=0; chipId<=1; chipId++) { // FE chips in double module
             int ibl2dHash;
             if (chipId) {
               if (modEta <= -1) ibl2dHash = m_nIblFes*i + iblFeHash; // C side, '_2'
               else ibl2dHash = m_nIblFes*i + iblFeHash + chipId; // A side, '_2'
             }
             else {
               if (modEta <= -1) ibl2dHash = m_nIblFes*i + iblFeHash + 1; // C side, '_1'
               else ibl2dHash = m_nIblFes*i + iblFeHash; // A side, '_1'
             }
             std::string histTitle = onlineID + "_" + std::to_string(chipId+1);
             // Occupancy Map
             axisTitle = ";pixel_eta;pixel_phi;# hits/pixel/event";
             m_occupancyMapsIBL2dLB[ibl2dHash] = std::make_unique<TH2F>(histTitle.c_str(), (histTitle+axisTitle).c_str(), 80, -0.5, 79.5, 336, -0.5, 335.5);
             name << "/histfile/" << LBCategory << "/" << occ2dDir << "/" << histoSuffix(bec,layer) << "/" << histTitle;
             name.str(""); name.clear();
             m_occupancyMapsIBL2dLB[ibl2dHash]->SetOption("colz");
  
             // ToT
             axisTitle = ";ToT;# hits";
             m_TOTdistributionsIBL2dLB[ibl2dHash] = std::make_unique<TH1F>(histTitle.c_str(), (histTitle+axisTitle).c_str(), 19, -0.5, 18.5);
             name << "/histfile/" << LBCategory << "/" << totDir << "/" << histoSuffix(bec,layer) << "/" << histTitle;
             name.str(""); name.clear();
           }
         }
         else { // IBL 3D
           int ibl2dHash = m_nIblFes*i + iblFeHash;
           // Occupancy Map
           axisTitle = ";pixel_eta;pixel_phi;# hits/pixel/event";
           m_occupancyMapsIBL2dLB[ibl2dHash] = std::make_unique<TH2F>(onlineID.c_str(), (onlineID+axisTitle).c_str(), 80, -0.5, 79.5, 336, -0.5, 335.5);
           name << "/histfile/" << LBCategory << "/" << occ2dDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
           name.str(""); name.clear();
           m_occupancyMapsIBL2dLB[ibl2dHash]->SetOption("colz");
  
           // ToT
           axisTitle = ";ToT;# hits";
           m_TOTdistributionsIBL2dLB[ibl2dHash] = std::make_unique<TH1F>(onlineID.c_str(), (onlineID+axisTitle).c_str(), 19, -0.5, 18.5);
           name << "/histfile/" << LBCategory << "/" << totDir << "/" << histoSuffix(bec,layer) << "/" << onlineID;
           name.str(""); name.clear();
         } // End of if ibl 2d
       } // End of loop of category: LB
     } // End of if IBL
   } // end loop in detector elements
  
   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 > HitMapBuilder::splitter	(	const std::string &	str,
		char	delim
	)

private

Definition at line 68 of file HitMapBuilder.cxx.

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

◆ splitter() [2/2]

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

private

Definition at line 59 of file HitMapBuilder.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_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_evt_lbMax

Gaudi::Property<int> HitMapBuilder::m_evt_lbMax {this,"LBMax",-1,"Last lumi block to consider"}

private

Definition at line 90 of file HitMapBuilder.h.

◆ m_evt_lbMin

Gaudi::Property<int> HitMapBuilder::m_evt_lbMin {this,"LBMin",0,"First lumi block to consider"}

private

Definition at line 89 of file HitMapBuilder.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_fei4bPixels

const int HitMapBuilder::m_fei4bPixels = 26880

private

Definition at line 98 of file HitMapBuilder.h.

◆ m_hist_lbMax

Gaudi::Property<int> HitMapBuilder::m_hist_lbMax {this,"nLBmax", 3001, "Maximum number of LB (for histograms binning)"}

private

Definition at line 88 of file HitMapBuilder.h.

◆ m_LBrange_max

int HitMapBuilder::m_LBrange_max = -9999

private

Definition at line 92 of file HitMapBuilder.h.

◆ m_nEvents

double HitMapBuilder::m_nEvents =0

private

Definition at line 76 of file HitMapBuilder.h.

◆ m_nEventsHist

std::unique_ptr<TH1F> HitMapBuilder::m_nEventsHist

private

Definition at line 80 of file HitMapBuilder.h.

◆ m_nEventsLB

std::vector<double> HitMapBuilder::m_nEventsLB

private

Definition at line 77 of file HitMapBuilder.h.

◆ m_nEventsLBCategory

std::vector<double> HitMapBuilder::m_nEventsLBCategory

private

Definition at line 78 of file HitMapBuilder.h.

◆ m_nEventsLBHist

std::unique_ptr<TH1F> HitMapBuilder::m_nEventsLBHist

private

Definition at line 81 of file HitMapBuilder.h.

◆ m_nIblFes

const unsigned int HitMapBuilder::m_nIblFes = 14 * (4 + 6*2) * 2

private

Definition at line 94 of file HitMapBuilder.h.

◆ m_occupancyLB

std::vector<std::unique_ptr<TH1F> > HitMapBuilder::m_occupancyLB

private

Definition at line 86 of file HitMapBuilder.h.

◆ m_occupancyMaps

std::vector<std::unique_ptr<TH2F> > HitMapBuilder::m_occupancyMaps

private

Definition at line 82 of file HitMapBuilder.h.

◆ m_occupancyMapsIBL2dLB

std::vector<std::unique_ptr<TH2F> > HitMapBuilder::m_occupancyMapsIBL2dLB

private

Definition at line 83 of file HitMapBuilder.h.

◆ m_perLB_max

const int HitMapBuilder::m_perLB_max =3000

private

Definition at line 95 of file HitMapBuilder.h.

◆ m_perLB_min

const int HitMapBuilder::m_perLB_min =0

private

Definition at line 95 of file HitMapBuilder.h.

◆ m_perLB_n

const int HitMapBuilder::m_perLB_n = (m_perLB_max-m_perLB_min)/m_perLB_step

private

Definition at line 96 of file HitMapBuilder.h.

◆ m_perLB_step

const int HitMapBuilder::m_perLB_step =100

private

Definition at line 95 of file HitMapBuilder.h.

◆ m_pixelID

const PixelID* HitMapBuilder::m_pixelID =nullptr

private

Definition at line 71 of file HitMapBuilder.h.

◆ m_pixelMapping

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

private

Definition at line 74 of file HitMapBuilder.h.

◆ m_pixelRDOKey

SG::ReadHandleKey<PixelRDO_Container> HitMapBuilder::m_pixelRDOKey {this,"PixelRDOKey","PixelRDOs","StoreGate Key of Pixel RDOs"}

private

Definition at line 68 of file HitMapBuilder.h.

◆ m_pixman

const InDetDD::PixelDetectorManager* HitMapBuilder::m_pixman =nullptr

private

Definition at line 70 of file HitMapBuilder.h.

◆ m_pixModPixels

const int HitMapBuilder::m_pixModPixels = 46080

private

Definition at line 99 of file HitMapBuilder.h.

◆ m_tHistSvc

ServiceHandle<ITHistSvc> HitMapBuilder::m_tHistSvc {this, "THistSvc", "THistSvc/THistSvc"}

private

Definition at line 67 of file HitMapBuilder.h.

◆ m_TOTdistributions

std::vector<std::unique_ptr<TH1F> > HitMapBuilder::m_TOTdistributions

private

Definition at line 84 of file HitMapBuilder.h.

◆ m_TOTdistributionsIBL2dLB

std::vector<std::unique_ptr<TH1F> > HitMapBuilder::m_TOTdistributionsIBL2dLB

private

Definition at line 85 of file HitMapBuilder.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

◆ ~HitMapBuilder()

Member Function Documentation

◆ AthAlgorithm()

◆ 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_detStore

◆ m_evt_lbMax

◆ m_evt_lbMin

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_fei4bPixels

◆ m_hist_lbMax

◆ m_LBrange_max

◆ m_nEvents

◆ m_nEventsHist

◆ m_nEventsLB

◆ m_nEventsLBCategory

◆ m_nEventsLBHist

◆ m_nIblFes

◆ m_occupancyLB

◆ m_occupancyMaps

◆ m_occupancyMapsIBL2dLB

◆ m_perLB_max

◆ m_perLB_min

◆ m_perLB_n

◆ m_perLB_step

◆ m_pixelID

◆ m_pixelMapping

◆ m_pixelRDOKey

◆ m_pixman

◆ m_pixModPixels

◆ m_tHistSvc

◆ m_TOTdistributions

◆ m_TOTdistributionsIBL2dLB

◆ m_varHandleArraysDeclared

◆ m_vhka