#include <TileTriggerDefaultCalibTool.h>

Inheritance diagram for TileTriggerDefaultCalibTool:

Public Member Functions
	TileTriggerDefaultCalibTool (const std::string &type, const std::string &name, const IInterface *pParent)
virtual	~TileTriggerDefaultCalibTool ()
virtual StatusCode	initialize () override
virtual StatusCode	initNtuple (int runNumber, int runType, TFile *rootfile) override
virtual StatusCode	execute () override
virtual StatusCode	finalizeCalculations () override
virtual StatusCode	writeNtuple (int runNumber, int runType, TFile *rootfile) override
virtual StatusCode	finalize () override
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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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
using	Tile = TileCalibUtils
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::string	m_ntupleID
int	m_maxNTT
unsigned int	m_nevpmt
const CaloLVL1_ID *	m_TT_ID
const TileHWID *	m_tileHWID
const TileID *	m_tileID
const TileCablingService *	m_tileCablingService
ToolHandle< TileCondToolEmscale >	m_tileToolEmscale
	main Tile Calibration tool
SG::ReadHandleKey< TileDQstatus >	m_dqStatusKey
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerKey
SG::ReadHandleKey< xAOD::TriggerTowerContainer >	m_triggerTowerContainerKey
ToolHandle< LVL1::IL1CaloTTIdTools >	m_l1CaloTTIdTools
float(*	m_meanTile )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_rmsTile )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_meanTileDAC )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_rmsTileDAC )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
int(*	m_ietaTile )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
int(*	m_iphiTile )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
int(*	m_ipmtTile )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
int(*	m_nEvtTile )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_meanL1Calo )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_rmsL1Calo )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_meanL1CaloDAC )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_rmsL1CaloDAC )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
int(*	m_ietaL1Calo )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
int(*	m_iphiL1Calo )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
int(*	m_ipmtL1Calo )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
int(*	m_nEvtL1Calo )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_meanTileL1Calo )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float(*	m_rmsTileL1Calo )[Tile::MAX_DRAWER][Tile::MAX_CHAN]
float	m_charge
unsigned int	m_ipmt
unsigned int	m_ipmtCount
unsigned int	m_ipmtOld
float	m_DACvalue
int	m_nEvtGlobal
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

Definition at line 33 of file TileTriggerDefaultCalibTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ Tile

using TileTriggerDefaultCalibTool::Tile = TileCalibUtils

private

Definition at line 71 of file TileTriggerDefaultCalibTool.h.

Constructor & Destructor Documentation

◆ TileTriggerDefaultCalibTool()

TileTriggerDefaultCalibTool::TileTriggerDefaultCalibTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pParent )

Definition at line 37 of file TileTriggerDefaultCalibTool.cxx.

                                                                                                                              :
  AthAlgTool(type, name, pParent)
  , m_TT_ID(nullptr)
  , m_tileHWID(nullptr)
  , m_tileID(nullptr)
  , m_tileCablingService(nullptr)
  , m_charge(0)
  , m_ipmt(0)
  , m_ipmtCount(0)
  , m_ipmtOld(0)
  , m_DACvalue(0)
  , m_nEvtGlobal(0)
{
  declareInterface<ITileCalibTool>( this );
  declareProperty("MaxNTriggerTowers", m_maxNTT=7200);
  declareProperty("NtupleID", m_ntupleID="h3000");
  declareProperty("NumEventPerPMT", m_nevpmt=195); // changed from 200 to 195
  
  m_meanTile = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_rmsTile = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_meanTileDAC = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_rmsTileDAC = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_ietaTile = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_iphiTile = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_ipmtTile = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_nEvtTile = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
 
  m_meanL1Calo = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_rmsL1Calo = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_meanL1CaloDAC = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_rmsL1CaloDAC = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_ietaL1Calo = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_iphiL1Calo = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_ipmtL1Calo = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_nEvtL1Calo = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
 
  m_meanTileL1Calo = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
  m_rmsTileL1Calo = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN]();
}

◆ ~TileTriggerDefaultCalibTool()

TileTriggerDefaultCalibTool::~TileTriggerDefaultCalibTool ( )

virtual

Definition at line 77 of file TileTriggerDefaultCalibTool.cxx.

{
  delete[] m_meanTile;
  delete[] m_rmsTile;
  delete[] m_meanTileDAC;
  delete[] m_rmsTileDAC;
  delete[] m_ietaTile;
  delete[] m_iphiTile;
  delete[] m_ipmtTile;
  delete[] m_nEvtTile;
  delete[] m_meanL1Calo;
  delete[] m_rmsL1Calo;
  delete[] m_meanL1CaloDAC;
  delete[] m_rmsL1CaloDAC;
  delete[] m_ietaL1Calo;
  delete[] m_iphiL1Calo;
  delete[] m_ipmtL1Calo;
  delete[] m_nEvtL1Calo;
  delete[] m_meanTileL1Calo;
  delete[] m_rmsTileL1Calo;
}      

Member Function Documentation

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode TileTriggerDefaultCalibTool::execute ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 135 of file TileTriggerDefaultCalibTool.cxx.

{
  ATH_MSG_DEBUG ( "executeTrigger()" );
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
 
  // Get TileRawChannelContainer
  SG::ReadHandle<TileRawChannelContainer> container(m_rawChannelContainerKey);
         ATH_CHECK( container.isValid() );
 
  ATH_MSG_DEBUG ( "second executeTrigger()" );
  // declare an array of pmt id for the trigger tower loop
  //coverity[STACK_USE]
  HWIdentifier chanIds[2][16][64][6];
  memset(chanIds, 0, sizeof(chanIds));
 
  // Get event's ext CIS parameters
  const uint32_t *cispar = dqStatus->cispar();
 
  // Mapping pmt2chan
  int chan_bar[54] = {4 ,1 ,2 ,3 ,0 ,-1 ,
              8 ,5 ,6 ,7 ,13,-1 ,
              10,9 ,12,11,14,-1 ,
              18,15,16,17,25,-1 ,
              20,19,22,21,24,-1 ,
              26,23,28,27,41,-1 ,
              32,29,34,33,44,-1 ,
              38,35,40,39,-1,-1 ,
              36,37,42,47,46,45 };
 
  int chan_ext[36] = {4, 5 ,2 ,3 ,16,-1 ,
              8, 9 ,17,-1,-1,-1 ,
              6, 7 ,14,15,38,-1 ,
              10,11,22,23,37,-1 ,
              20,21,30,35,-1,-1 ,
              31,32,39,36,41,40 };
 
  ATH_MSG_DEBUG ( "cispar[16] " << cispar[16] << ", cispas[17] " << cispar[17] << ", cispar[18] " << cispar[18] );
  if (cispar[16] == 0x07){
      if (cispar[18]>5) {
          ATH_MSG_WARNING ( "Bad CISpar detected, using pmt index and charge from previous event: " << m_ipmt << " " << m_charge );
      } else {
          m_charge = cispar[17];
          m_ipmt = cispar[18];
          //m_itower = cispar[19];
          //m_idrawer = cispar[20];
      }
  }
  else if (cispar[16] == 0x107){ // bad CISpar
      ATH_MSG_WARNING ( "Bad CISpar detected, using pmt index and charge from previous event: " << m_ipmt << " " << m_charge );
  }
  else
      return StatusCode::SUCCESS;
  
  ATH_MSG_DEBUG ( "Pattern/ipmt/charge: " << cispar[16] << " " << m_ipmt << " " << m_charge );
  if (m_charge<1.0e-20) {
      ATH_MSG_WARNING ( "Bad charge " << m_charge << " - skipping event" );
      return StatusCode::SUCCESS;
  }
  
  if (m_ipmtOld != m_ipmt){
    if (m_ipmt < m_ipmtOld) return StatusCode::SUCCESS;
    m_ipmtCount = 1;
    m_ipmtOld = m_ipmt;
  }
  else
    m_ipmtCount += 1;
           
  if (m_ipmtCount > m_nevpmt) return StatusCode::SUCCESS;  //takes into account only the first m_nevpmt events for each pmt to avoid problem with wrong CISpar
 
  m_DACvalue = m_charge;
  
  // Create iterator over RawChannelContainer for Tile
  TileRawChannelContainer::const_iterator itColl = (*container).begin();
  TileRawChannelContainer::const_iterator itCollEnd = (*container).end();
  TileRawChannelCollection::const_iterator it, itEnd;
  TileRawChannelUnit::UNIT RChUnit = container->get_unit();
 
  //     Go through all TileRawChannelCollections
  for(; itColl != itCollEnd; ++itColl) {
    
    //go through all TileRawChannels in collection (loop over all channels)
    it = (*itColl)->begin();
    itEnd = (*itColl)->end();
       
    for(; it != itEnd; ++it) {
  
      // get hardware id to identify adc channel
      HWIdentifier hwid=(*it)->adc_HWID();
      //ATH_MSG_DEBUG("HWID1: "<< m_tileHWID->to_string(hwid));
      int ros    = m_tileHWID->ros(hwid);    // LBA=1  LBC=2  EBA=3  EBC=4 
      int drawer = m_tileHWID->drawer(hwid); // 0 to 63
      int chan = m_tileHWID->channel(hwid);  // 0 to 47 channel not PMT
      int gain = m_tileHWID->adc(hwid); // low=0 high=1
      unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
      // Get the PMT Id, create on the fly a mapping to the trigger tower id
      // this mapping is to be used below in the loop over all trigger towers
      Identifier tt_id = (*it)->tt_ID();
      if (!tt_id.is_valid()) continue;
      //Identifier pmt_id = (*it)->pmt_ID();
 
      int pos_neg_z = m_TT_ID->pos_neg_z(tt_id);
      int ieta = m_TT_ID->eta(tt_id);
      int iphi = m_TT_ID->phi(tt_id);
 
      if (ros < 3) {
        if (ieta < 0 || ieta > 8) continue;
      } else {
        if (ieta < 9 || ieta > 14) continue;
      }
 
      if((ros==1) || (ros==2)){
        // (Manually fold constants to avoid cppcheck warning.)
    if (chan != chan_bar[(ieta*6)/*-1*/ + m_ipmt/*+1*/]) continue;    // check if the chan is firing
      }
      else if ((ros==3) || (ros==4)){
    if ((chan != chan_ext[((ieta-9)*6)/*-1*/ + m_ipmt/*+1*/]) || (chan == 0)) continue;   // check if the chan is firing
      }
      else
    continue;
 
      float amp = (*it)->amplitude();
      float amp_pC = m_tileToolEmscale->channelCalib(drawerIdx, chan, gain, amp, RChUnit, TileRawChannelUnit::PicoCoulombs);
      //float amp_GeV = m_tileToolEmscale->channelCalib(drawerIdx, chan, gain, amp, RChUnit, TileRawChannelUnit::MegaElectronVolts) * 0.001;
      //float pC2GeV = m_tileToolEmscale->channelCalib(drawerIdx, chan, 0, 1.0, TileRawChannelUnit::PicoCoulombs, TileRawChannelUnit::MegaElectronVolts) * 0.001;
      //log << MSG::DEBUG << "ros " << ros << ", pos_neg_z " << pos_neg_z << ", drawer " << drawer <<" ieta " << ieta <<  ", chan " << chan << ", amplitude " << amp << endreq;
      
      m_meanTile[ros][drawer][chan] += amp_pC;
      m_rmsTile[ros][drawer][chan]  += square(amp_pC);
      m_meanTileDAC[ros][drawer][chan] += (amp_pC-m_charge);
      m_rmsTileDAC[ros][drawer][chan]  += square(amp_pC-m_charge);
      m_ietaTile[ros][drawer][chan]  = ieta;
      m_iphiTile[ros][drawer][chan]  = iphi;
      m_ipmtTile[ros][drawer][chan]  = m_ipmt;
      ++m_nEvtTile[ros][drawer][chan];
 
      if (pos_neg_z < 0) pos_neg_z = 0;
      chanIds[pos_neg_z][ieta][iphi][m_ipmt] = hwid;
    }
 
  } // end of loop over raw channels for Tile
  
  // loop over all L1Calo trigger channels, calculate the average and RMS
  SG::ReadHandle<xAOD::TriggerTowerContainer> triggerTowers(m_triggerTowerContainerKey);
  ATH_CHECK( triggerTowers.isValid() );
 
  int ntt = 0;
 
  for (const xAOD::TriggerTower* triggerTower : *triggerTowers) {
 
    if(ntt>m_maxNTT) break;
 
    if (!triggerTower->sampling()) continue; // is not hadronic
 
    double eta = triggerTower->eta();
    double phi = triggerTower->phi();
    double tt_ene = 0.;  //triggerTower->e();
 
    // temporary, compute id out of the tower position
    int pos_neg_z = m_l1CaloTTIdTools->pos_neg_z(eta);
    int region = m_l1CaloTTIdTools->regionIndex(eta);
    int ieta   = m_l1CaloTTIdTools->etaIndex(eta);
    int iphi   = m_l1CaloTTIdTools->phiIndex(eta, phi);
    Identifier tt_id = m_TT_ID->tower_id(pos_neg_z, 1, region, ieta, iphi);
    //Not used, but could be useful, eg. coolId is used to get proper pedestal value
    //Identifier id = m_ttTool->identifier(triggerTower->eta(), triggerTower->phi(), 1); //alternative way to get tt_id
    //unsigned int coolId = m_ttTool->channelID(tt_id).id();
    
    // check if it is a Tile tower
    if (tt_id.is_valid() && m_TT_ID->is_tile(tt_id)) 
        ++ntt;
    else continue;
 
    //compute L1Calo energy from ADC:
    // - take max ADC value
    // - subtract pedestal (about 32 ADC counts), apply 0.25 conversion factor to GeV 
    const std::vector<uint16_t>& adc = triggerTower->adc();
    uint16_t max = *(std::max_element(adc.begin(), adc.end()));
    uint16_t ped = adc.front(); 
    tt_ene = (max - ped) * 0.25; 
    if (tt_ene < 0.) tt_ene = 0.;
 
    // check boundaries
    if ((ieta < 0) || (ieta > 14)) continue;
 
    if (pos_neg_z < 0) pos_neg_z = 0;
    HWIdentifier hwid = chanIds[pos_neg_z][ieta][iphi][m_ipmt];
    int ros    = m_tileHWID->ros(hwid);    // LBA=1  LBC=2  EBA=3  EBC=4 
    if(ros >= 5 || ros <=0){continue;} // ignoring special channels, like those connected to inner MBTS in EBA/EBC 39-42,55-58 
    int drawer = m_tileHWID->drawer(hwid); // 0 to 63
    int chan = m_tileHWID->channel(hwid);  // 0 to 47 channel not PMT
    unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
    float pC2GeV = m_tileToolEmscale->channelCalib(drawerIdx, chan, 0, 1.0, TileRawChannelUnit::PicoCoulombs, TileRawChannelUnit::MegaElectronVolts) * 0.001;
    double tt_ene_pC = tt_ene / pC2GeV;
 
    //comparing results from triggerTower->e() and energy computed from ADC (default method)
    if (triggerTower->e() == 0) 
      ATH_MSG_DEBUG ( "Tower partition " << ros 
                      << ", drawer "<< drawer 
                      << ", chan: " << chan 
                      << ", eta "<< eta 
                      << ", phi: " << phi 
                      << ", amplitude : "  << tt_ene 
                      << ", old " << triggerTower->e() 
                      << ", ratio old/new " << (tt_ene == 0 ? 0 : triggerTower->e() / tt_ene ));
 
    if ((ros==1) || (ros==2)){ 
      if (chan != chan_bar[(ieta*6)-1 + m_ipmt+1]) continue;          // check if the chan is firing    
    }
    else if ((ros==3) || (ros==4)) {
      if ((chan != chan_ext[((ieta-9)*6)-1 + m_ipmt+1]) || (chan == 0)) continue; // check if the chan is firing
    }
    else continue;
 
    m_meanL1Calo[ros][drawer][chan] += tt_ene_pC;
    m_rmsL1Calo[ros][drawer][chan]  += square(tt_ene_pC);
    m_meanL1CaloDAC[ros][drawer][chan] += tt_ene_pC - m_charge;
    m_rmsL1CaloDAC[ros][drawer][chan]  += square(tt_ene_pC - m_charge);
    m_ietaL1Calo[ros][drawer][chan]  = ieta;
    m_iphiL1Calo[ros][drawer][chan]  = iphi;
    m_ipmtL1Calo[ros][drawer][chan]  = m_ipmt;
    ++m_nEvtL1Calo[ros][drawer][chan];
    
  }// end of trigger tower loop for L1Calo
 
  ++m_nEvtGlobal; // Number of MaxEvt from Athena
 
  for (int ros=0;ros<5;ros++) {
    for (int drawer=0;drawer<64;drawer++) {
      for (int chan=0;chan<48;chan++) {
        // ???
    m_rmsTileL1Calo[ros][drawer][chan] += m_meanTile[ros][drawer][chan]*m_meanL1Calo[ros][drawer][chan];
      }
    }
  }
 
  return StatusCode::SUCCESS;
 
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ finalize()

StatusCode TileTriggerDefaultCalibTool::finalize ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 465 of file TileTriggerDefaultCalibTool.cxx.

{
  ATH_MSG_DEBUG ( "finalizeTrigger()" );
  return StatusCode::SUCCESS;  
}

◆ finalizeCalculations()

StatusCode TileTriggerDefaultCalibTool::finalizeCalculations ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 377 of file TileTriggerDefaultCalibTool.cxx.

{
  ATH_MSG_INFO ( "finalizeCalculations()" );
  
  for (int ros=0;ros<5;ros++) {
    for (int drawer=0;drawer<64;drawer++) {
      for (int chan=0;chan<48;chan++) {
    if (m_nEvtTile[ros][drawer][chan] > 0){
      m_meanTile[ros][drawer][chan] /= m_nEvtTile[ros][drawer][chan];
      m_rmsTile[ros][drawer][chan]  /= m_nEvtTile[ros][drawer][chan];
      m_meanTileDAC[ros][drawer][chan] /= m_nEvtTile[ros][drawer][chan];
      m_rmsTileDAC[ros][drawer][chan]  /= m_nEvtTile[ros][drawer][chan];
    }
    
    if(m_rmsTile[ros][drawer][chan] <= square(m_meanTile[ros][drawer][chan]))
      m_rmsTile[ros][drawer][chan] = 0;
    else 
      m_rmsTile[ros][drawer][chan] = sqrt(m_rmsTile[ros][drawer][chan] - square(m_meanTile[ros][drawer][chan]));
    
    if(m_rmsTileDAC[ros][drawer][chan] <= square(m_meanTileDAC[ros][drawer][chan]))
      m_rmsTileDAC[ros][drawer][chan] = 0;
    else 
      m_rmsTileDAC[ros][drawer][chan] = sqrt(m_rmsTileDAC[ros][drawer][chan] - square(m_meanTileDAC[ros][drawer][chan]));
 
    if (m_nEvtL1Calo[ros][drawer][chan] > 0){ 
      m_meanL1Calo[ros][drawer][chan] /= m_nEvtL1Calo[ros][drawer][chan];
      m_rmsL1Calo[ros][drawer][chan]  /= m_nEvtL1Calo[ros][drawer][chan];
      m_meanL1CaloDAC[ros][drawer][chan] /= m_nEvtL1Calo[ros][drawer][chan];
      m_rmsL1CaloDAC[ros][drawer][chan]  /= m_nEvtL1Calo[ros][drawer][chan];
    }
    
    if(m_rmsL1Calo[ros][drawer][chan] <= square(m_meanL1Calo[ros][drawer][chan]))
      m_rmsL1Calo[ros][drawer][chan] = 0;
    else 
      m_rmsL1Calo[ros][drawer][chan] = sqrt(m_rmsL1Calo[ros][drawer][chan] - square(m_meanL1Calo[ros][drawer][chan]));
 
    if(m_rmsL1CaloDAC[ros][drawer][chan] <= square(m_meanL1CaloDAC[ros][drawer][chan]))
      m_rmsL1CaloDAC[ros][drawer][chan] = 0;
    else 
      m_rmsL1CaloDAC[ros][drawer][chan] = sqrt(m_rmsL1CaloDAC[ros][drawer][chan] - square(m_meanL1CaloDAC[ros][drawer][chan]));
 
    m_meanTileL1Calo[ros][drawer][chan] = m_meanTile[ros][drawer][chan] - m_meanL1Calo[ros][drawer][chan];
        if(m_rmsTileL1Calo[ros][drawer][chan] <= square(m_meanTileL1Calo[ros][drawer][chan]))
      m_rmsTileL1Calo[ros][drawer][chan] = 0;
    else 
      m_rmsTileL1Calo[ros][drawer][chan] = sqrt(m_rmsTileL1Calo[ros][drawer][chan] - square(m_meanTileL1Calo[ros][drawer][chan]));
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode TileTriggerDefaultCalibTool::initialize ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 99 of file TileTriggerDefaultCalibTool.cxx.

{
  ATH_MSG_INFO ( "initialize()" );
 
  // Initialize arrays for results
  m_charge = 0;
  m_ipmt = 0;
  m_ipmtOld = 0;
  m_ipmtCount = 0;
 
  ATH_CHECK( m_rawChannelContainerKey.initialize() );
  ATH_CHECK( m_triggerTowerContainerKey.initialize() );
 
  ATH_CHECK( m_l1CaloTTIdTools.retrieve() );
  ATH_MSG_DEBUG("L1CaloTTIdTools retrieved");
 
  ATH_CHECK( detStore()->retrieve(m_TT_ID) );
  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
  ATH_CHECK( detStore()->retrieve(m_tileID) );
 
  m_tileCablingService = TileCablingService::getInstance();
 
  //=== get TileCondToolEmscale
  CHECK( m_tileToolEmscale.retrieve() );
  
  CHECK( m_dqStatusKey.initialize() );
 
  return StatusCode::SUCCESS;  
}

◆ initNtuple()

StatusCode TileTriggerDefaultCalibTool::initNtuple	(	int	runNumber,
		int	runType,
		TFile *	rootfile )

overridevirtual

Implements ITileCalibTool.

Definition at line 129 of file TileTriggerDefaultCalibTool.cxx.

{
  ATH_MSG_INFO ( "initialize(" << runNumber << "," << runType << "," << rootFile << ")" );
  return StatusCode::SUCCESS;  
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ interfaceID()

const InterfaceID & ITileCalibTool::interfaceID ( )

inlinestaticinherited

Definition at line 21 of file ITileCalibTool.h.

21{ return IID_ITileCalibTool; }

IID_ITileCalibTool

static const InterfaceID IID_ITileCalibTool("ITileCalibTool", 1, 0)

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

◆ 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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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);
      }
    }
  }

◆ writeNtuple()

StatusCode TileTriggerDefaultCalibTool::writeNtuple	(	int	runNumber,
		int	runType,
		TFile *	rootfile )

overridevirtual

Implements ITileCalibTool.

Definition at line 430 of file TileTriggerDefaultCalibTool.cxx.

{
  ATH_MSG_INFO ( "writeNtuple(" << runNumber << "," << runType << "," << rootFile << ")" );
 
  TTree *t = new TTree(m_ntupleID.c_str(), "TileCalib-Ntuple");
  TString ind = TString::Format("[%d][%d][%d]",Tile::MAX_ROS,Tile::MAX_DRAWER,Tile::MAX_CHAN);
 
  t->Branch("meanTile",m_meanTile,ind.Format("meanTile%s/F",(const char *)ind));
  t->Branch("rmsTile",m_rmsTile,ind.Format("rmsTile%s/F",(const char *)ind));
  t->Branch("meanTileDAC",m_meanTileDAC,ind.Format("meanTileDAC%s/F",(const char *)ind));
  t->Branch("rmsTileDAC",m_rmsTileDAC,ind.Format("rmsTileDAC%s/F",(const char *)ind));
  t->Branch("ietaTile",m_ietaTile,ind.Format("ietaTile%s/I",(const char *)ind));
  t->Branch("iphiTile",m_iphiTile,ind.Format("iphiTile%s/I",(const char *)ind));
  t->Branch("ipmtTile",m_ipmtTile,ind.Format("ipmtTile%s/I",(const char *)ind));
  t->Branch("nEvtTile",m_nEvtTile,ind.Format("nEvtTile%s/I",(const char *)ind));
  t->Branch("meanL1Calo",m_meanL1Calo,ind.Format("meanL1Calo%s/F",(const char *)ind));
  t->Branch("rmsL1Calo",m_rmsL1Calo,ind.Format("rmsL1Calo%s/F",(const char *)ind));
  t->Branch("meanL1CaloDAC",m_meanL1CaloDAC,ind.Format("meanL1CaloDAC%s/F",(const char *)ind));
  t->Branch("rmsL1CaloDAC",m_rmsL1CaloDAC,ind.Format("rmsL1CaloDAC%s/F",(const char *)ind));
  t->Branch("ietaL1Calo",m_ietaL1Calo,ind.Format("ietaL1Calo%s/I",(const char *)ind));
  t->Branch("iphiL1Calo",m_iphiL1Calo,ind.Format("iphiL1Calo%s/I",(const char *)ind));
  t->Branch("ipmtL1Calo",m_ipmtL1Calo,ind.Format("ipmtL1Calo%s/I",(const char *)ind));
  t->Branch("nEvtL1Calo",m_nEvtL1Calo,ind.Format("nEvtL1Calo%s/I",(const char *)ind));
  t->Branch("meanTileL1Calo",m_meanTileL1Calo,ind.Format("meanTileL1Calo%s/F",(const char *)ind));
  t->Branch("rmsTileL1Calo",m_rmsTileL1Calo,ind.Format("rmsTileL1Calo%s/F",(const char *)ind));
  t->Branch("nEvtGlobal",&m_nEvtGlobal,"nEvtGlobal/I");
  t->Branch("DACvalue",&m_DACvalue,"DACvalue/F");
 
  // Fill with current values (i.e. tree will have only one entry for this whole run)
  t->Fill();
  t->Write();
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

◆ m_charge

float TileTriggerDefaultCalibTool::m_charge

private

Definition at line 97 of file TileTriggerDefaultCalibTool.h.

◆ m_DACvalue

float TileTriggerDefaultCalibTool::m_DACvalue

private

Definition at line 102 of file TileTriggerDefaultCalibTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_dqStatusKey

SG::ReadHandleKey<TileDQstatus> TileTriggerDefaultCalibTool::m_dqStatusKey

private

Initial value:

{this,

"TileDQstatus", "TileDQstatus", "TileDQstatus key"}

Definition at line 61 of file TileTriggerDefaultCalibTool.h.

61 {this,

62 "TileDQstatus", "TileDQstatus", "TileDQstatus key"};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_ietaL1Calo

int(* TileTriggerDefaultCalibTool::m_ietaL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 88 of file TileTriggerDefaultCalibTool.h.

◆ m_ietaTile

int(* TileTriggerDefaultCalibTool::m_ietaTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 78 of file TileTriggerDefaultCalibTool.h.

◆ m_iphiL1Calo

int(* TileTriggerDefaultCalibTool::m_iphiL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 89 of file TileTriggerDefaultCalibTool.h.

◆ m_iphiTile

int(* TileTriggerDefaultCalibTool::m_iphiTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 79 of file TileTriggerDefaultCalibTool.h.

◆ m_ipmt

unsigned int TileTriggerDefaultCalibTool::m_ipmt

private

Definition at line 98 of file TileTriggerDefaultCalibTool.h.

◆ m_ipmtCount

unsigned int TileTriggerDefaultCalibTool::m_ipmtCount

private

Definition at line 99 of file TileTriggerDefaultCalibTool.h.

◆ m_ipmtL1Calo

int(* TileTriggerDefaultCalibTool::m_ipmtL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 90 of file TileTriggerDefaultCalibTool.h.

◆ m_ipmtOld

unsigned int TileTriggerDefaultCalibTool::m_ipmtOld

private

Definition at line 100 of file TileTriggerDefaultCalibTool.h.

◆ m_ipmtTile

int(* TileTriggerDefaultCalibTool::m_ipmtTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 80 of file TileTriggerDefaultCalibTool.h.

◆ m_l1CaloTTIdTools

ToolHandle<LVL1::IL1CaloTTIdTools > TileTriggerDefaultCalibTool::m_l1CaloTTIdTools

private

Initial value:

{this,

"L1CaloTTIdTools", "LVL1::L1CaloTTIdTools/L1CaloTTIdTools", "L1Calo TTId tools"}

Definition at line 68 of file TileTriggerDefaultCalibTool.h.

68 {this,

69 "L1CaloTTIdTools", "LVL1::L1CaloTTIdTools/L1CaloTTIdTools", "L1Calo TTId tools"};

◆ m_maxNTT

int TileTriggerDefaultCalibTool::m_maxNTT

private

Definition at line 51 of file TileTriggerDefaultCalibTool.h.

◆ m_meanL1Calo

float(* TileTriggerDefaultCalibTool::m_meanL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 84 of file TileTriggerDefaultCalibTool.h.

◆ m_meanL1CaloDAC

float(* TileTriggerDefaultCalibTool::m_meanL1CaloDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 86 of file TileTriggerDefaultCalibTool.h.

◆ m_meanTile

float(* TileTriggerDefaultCalibTool::m_meanTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 74 of file TileTriggerDefaultCalibTool.h.

◆ m_meanTileDAC

float(* TileTriggerDefaultCalibTool::m_meanTileDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 76 of file TileTriggerDefaultCalibTool.h.

◆ m_meanTileL1Calo

float(* TileTriggerDefaultCalibTool::m_meanTileL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 93 of file TileTriggerDefaultCalibTool.h.

◆ m_nevpmt

unsigned int TileTriggerDefaultCalibTool::m_nevpmt

private

Definition at line 52 of file TileTriggerDefaultCalibTool.h.

◆ m_nEvtGlobal

int TileTriggerDefaultCalibTool::m_nEvtGlobal

private

Definition at line 105 of file TileTriggerDefaultCalibTool.h.

◆ m_nEvtL1Calo

int(* TileTriggerDefaultCalibTool::m_nEvtL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 91 of file TileTriggerDefaultCalibTool.h.

◆ m_nEvtTile

int(* TileTriggerDefaultCalibTool::m_nEvtTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 81 of file TileTriggerDefaultCalibTool.h.

◆ m_ntupleID

std::string TileTriggerDefaultCalibTool::m_ntupleID

private

Definition at line 50 of file TileTriggerDefaultCalibTool.h.

◆ m_rawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileTriggerDefaultCalibTool::m_rawChannelContainerKey

private

Initial value:

{this,

"TileRawChannelContainer", "TileRawChannelFit", "Tile raw channel container"}

Definition at line 63 of file TileTriggerDefaultCalibTool.h.

63 {this,

64 "TileRawChannelContainer", "TileRawChannelFit", "Tile raw channel container"};

◆ m_rmsL1Calo

float(* TileTriggerDefaultCalibTool::m_rmsL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 85 of file TileTriggerDefaultCalibTool.h.

◆ m_rmsL1CaloDAC

float(* TileTriggerDefaultCalibTool::m_rmsL1CaloDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 87 of file TileTriggerDefaultCalibTool.h.

◆ m_rmsTile

float(* TileTriggerDefaultCalibTool::m_rmsTile)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 75 of file TileTriggerDefaultCalibTool.h.

◆ m_rmsTileDAC

float(* TileTriggerDefaultCalibTool::m_rmsTileDAC)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 77 of file TileTriggerDefaultCalibTool.h.

◆ m_rmsTileL1Calo

float(* TileTriggerDefaultCalibTool::m_rmsTileL1Calo)[Tile::MAX_DRAWER][Tile::MAX_CHAN]

private

Definition at line 94 of file TileTriggerDefaultCalibTool.h.

◆ m_tileCablingService

const TileCablingService* TileTriggerDefaultCalibTool::m_tileCablingService

private

Definition at line 58 of file TileTriggerDefaultCalibTool.h.

◆ m_tileHWID

const TileHWID* TileTriggerDefaultCalibTool::m_tileHWID

private

Definition at line 56 of file TileTriggerDefaultCalibTool.h.

◆ m_tileID

const TileID* TileTriggerDefaultCalibTool::m_tileID

private

Definition at line 57 of file TileTriggerDefaultCalibTool.h.

◆ m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileTriggerDefaultCalibTool::m_tileToolEmscale

private

Initial value:

{this,

"TileCondToolEmscale", "TileCondToolEmscale", "Tile em scale tool"}

main Tile Calibration tool

Definition at line 59 of file TileTriggerDefaultCalibTool.h.

59 {this,

60 "TileCondToolEmscale", "TileCondToolEmscale", "Tile em scale tool"};

◆ m_triggerTowerContainerKey

SG::ReadHandleKey<xAOD::TriggerTowerContainer> TileTriggerDefaultCalibTool::m_triggerTowerContainerKey

private

Initial value:

{this,

"TriggerTowerContainer", "xAODTriggerTowers", "Trigger Tower container"}

Definition at line 65 of file TileTriggerDefaultCalibTool.h.

65 {this,

66 "TriggerTowerContainer", "xAODTriggerTowers", "Trigger Tower container"};

◆ m_TT_ID

const CaloLVL1_ID* TileTriggerDefaultCalibTool::m_TT_ID

private

Definition at line 55 of file TileTriggerDefaultCalibTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ Tile

Constructor & Destructor Documentation

◆ TileTriggerDefaultCalibTool()

◆ ~TileTriggerDefaultCalibTool()

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ finalize()

◆ finalizeCalculations()

◆ initialize()

◆ initNtuple()

◆ inputHandles()

◆ interfaceID()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ writeNtuple()

Member Data Documentation

◆ m_charge

◆ m_DACvalue

◆ m_detStore

◆ m_dqStatusKey

◆ m_evtStore

◆ m_ietaL1Calo

◆ m_ietaTile

◆ m_iphiL1Calo

◆ m_iphiTile

◆ m_ipmt

◆ m_ipmtCount

◆ m_ipmtL1Calo

◆ m_ipmtOld

◆ m_ipmtTile

◆ m_l1CaloTTIdTools

◆ m_maxNTT

◆ m_meanL1Calo

◆ m_meanL1CaloDAC

◆ m_meanTile

◆ m_meanTileDAC

◆ m_meanTileL1Calo

◆ m_nevpmt

◆ m_nEvtGlobal

◆ m_nEvtL1Calo

◆ m_nEvtTile

◆ m_ntupleID

◆ m_rawChannelContainerKey

◆ m_rmsL1Calo

◆ m_rmsL1CaloDAC

◆ m_rmsTile

◆ m_rmsTileDAC

◆ m_rmsTileL1Calo

◆ m_tileCablingService

◆ m_tileHWID

◆ m_tileID

◆ m_tileToolEmscale

◆ m_triggerTowerContainerKey

◆ m_TT_ID

◆ m_varHandleArraysDeclared

◆ m_vhka