HitMapBuilder Class Reference

HitMapBuilder.h. More...

#include <HitMapBuilder.h>

Inheritance diagram for HitMapBuilder:

Public Member Functions
	~HitMapBuilder ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
	AthAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters:
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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 + 6*2) * 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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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.

                              {
}

Member Function Documentation

AthAlgorithm()

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

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()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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.

{ return m_detStore; }

evtStore()

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.

{ 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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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, AthHistogramAlgorithm, and PyAthena::Alg.

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.

{this,"LBMax",-1,"Last lumi block to consider"}; // upper limit for LB to be taken into account

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.

{this,"LBMin",0,"First lumi block to consider"}; // lower limit for LB to be taken into account

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.

{this,"nLBmax", 3001, "Maximum number of LB (for histograms binning)"};   // max number of LB

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.

{this,"PixelRDOKey","PixelRDOs","StoreGate Key of Pixel RDOs"};

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.

{this, "THistSvc", "THistSvc/THistSvc"};

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:

• HitMapBuilder.h
• HitMapBuilder.cxx