ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
TileAANtuple Class Reference

class to produce TileCal commissioning ntuples More...

#include <TileAANtuple.h>

Inheritance diagram for TileAANtuple:
Collaboration diagram for TileAANtuple:

Classes

struct  Arrays
 

Public Member Functions

 TileAANtuple (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TileAANtuple ()
 
StatusCode ntuple_initialize (const EventContext &ctx, const TileDQstatus &DQstatus)
 
StatusCode ntuple_clear ()
 
StatusCode initialize ()
 Alg standard interface function. More...
 
StatusCode execute ()
 
StatusCode finalize ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode storeRawChannels (const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, float ene[N_ROS2][N_MODULES][N_CHANS], float time[N_ROS2][N_MODULES][N_CHANS], float chi2[N_ROS2][N_MODULES][N_CHANS], float ped[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
 / Fill ntuple with data from TRC. More...
 
StatusCode storeMFRawChannels (const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, float *ene, float *time, float chi2[N_ROS2][N_MODULES][N_CHANS], float ped[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
 
StatusCode storeDigits (const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey, short *sample, short gain[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
 / Fill Ntuple with info from TileDigits / Return true if the collection is empty More...
 
StatusCode storeTMDBDecision (const EventContext &ctx)
 
StatusCode storeTMDBDigits (const EventContext &ctx)
 
StatusCode storeTMDBRawChannel (const EventContext &ctxx)
 
StatusCode storeBeamElements (const TileDQstatus &DQstatus)
 
StatusCode storeLaser (const EventContext &ctx)
 
StatusCode storeDCS ()
 
StatusCode initNTuple (const EventContext &ctx)
 
void fillCellMap (TTree *ntuplePtr)
 /////////////////////////////////////////////////////////////////////////// More...
 
void TRIGGER_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add TRIGGER variables to the Tree More...
 
void LASER_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree LASER variables Tree More...
 
void CISPAR_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variables Tree More...
 
void DIGI_addBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables Tree More...
 
void DCS_addBranch (void)
 
void TMDB_addBranch (void)
 
void TRIGGER_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER variables More...
 
void LASER_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree LASER variables More...
 
void CISPAR_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variables More...
 
void DIGI_clearBranch (void)
 //////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variables //////////////////////////////////////////////////////////////////////////// More...
 
void TMDB_clearBranch (void)
 
int digiChannel2PMT (int fragType, int chan)
 
short CheckDMUFormat (uint32_t header)
 bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0 More...
 
short CheckDMUParity (uint32_t header)
 Parity of the DMU header should be odd. More...
 
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

int m_evtNr
 event counter More...
 
int m_evTime
 event time More...
 
int m_run
 run number More...
 
int m_evt
 event number in a run More...
 
int m_lumiBlock
 lumiblock number in a run More...
 
int m_HHMMSS
 event time in HH:MM:SS More...
 
char m_dateTime [32]
 event date and time More...
 
int m_trigType
 trigger type (1=Phys, 2=Laser, 4=Ped, 8=CIS) More...
 
uint32_t m_dspFlags
 DSP flags from BS. More...
 
int m_l1ID [N_RODS]
 Level1 ID from ROD header. More...
 
int m_l1Type [N_RODS]
 Level1 Type from ROD header. More...
 
int m_evBCID [N_RODS]
 Event BCID from ROD header. More...
 
int m_evType [N_RODS]
 Event Type from ROD header. More...
 
uint32_t m_cispar [N_CISPAR]
 
int m_las_version
 
int m_las_BCID
 
int m_las_Filt
 
float m_las_ReqAmp
 
float m_las_MeasAmp
 
float m_las_Temperature
 
std::unique_ptr< Arrays > m_arrays
 
bool m_qdctimeout
 
bool m_tdctimeout
 
int m_daqtype
 
int m_nBadDr
 
int m_nBadHV
 
int m_nBadDCS
 
int m_nBadDB
 
int m_nBadTotal
 
int m_nSamples =0
 number of samples More...
 
bool m_reduced
 
int m_compressSettings
 
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
 
SG::ReadHandleKey< TileDigitsContainer > m_fltDigitsContainerKey
 
SG::ReadHandleKey< TileBeamElemContainer > m_beamElemContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_fitRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_optRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_qieRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_mfRawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_of1RawChannelContainerKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_wienerRawChannelContainerKey
 
SG::ReadHandleKey< TileLaserObject > m_laserObjectKey
 
SG::ReadHandleKey< TileRawChannelContainer > m_tileMuRcvRawChannelContainerKey
 
SG::ReadHandleKey< TileDigitsContainer > m_tileMuRcvDigitsContainerKey
 
SG::ReadHandleKey< TileMuonReceiverContainer > m_tileMuRcvContainerKey
 
SG::ReadHandleKey< TileL2Container > m_l2CntKey
 
bool m_calibrateEnergy
 convert energy to new units or use amplitude from RawChannel directly More...
 
bool m_useDspUnits
 true if energy should be converted to units used in DSP More...
 
bool m_bsInput
 true if bytestream file is used More...
 
bool m_pmtOrder
 change channel ordering to pmt ordering in ntuple More...
 
int m_finalUnit
 calibrate everything to this level More...
 
bool m_calibMode
 If data should be put in calib mode. More...
 
bool m_compareMode
 If two sets of data should be compared (e.g. More...
 
bool m_checkDCS
 if false, do not use TileDCS at all More...
 
int m_DCSBranches
 mask like 110101 - which DCS branches to fill More...
 
TileRawChannelUnit::UNIT m_rchUnit
 Unit for TileRawChannels (ADC, pCb, MeV) More...
 
TileRawChannelUnit::UNIT m_dspUnit
 Unit for TileRawChannels in DSP. More...
 
std::string m_streamName
 
std::string m_ntupleID
 
int64_t m_treeSize
 
TTree * m_ntuplePtr
 
TTree * m_DCSntuplePtr
 
ServiceHandle< ITHistSvc > m_thistSvc
 
ServiceHandle< IFileMgr > m_fileMgr
 
const TileID * m_tileID
 
const TileHWID * m_tileHWID
 
const TileCablingService * m_cabling
 cabling tool More...
 
const TileDetDescrManager * m_tileMgr
 Pointer to TileDetDescrManager. More...
 
ToolHandle< ITileBadChanTool > m_tileBadChanTool
 Tile Bad Channel tool. More...
 
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
 main Tile Calibration tool More...
 
ToolHandle< ITileDCSTool > m_tileDCS {this, "TileDCSTool", "TileDCSTool", "Tile DCS tool"}
 
ToolHandle< TileL2Builder > m_l2Builder
 
float m_sumEt_xx [N_DRAWERS]
 Sum Et recalculated offline using DSP raw channels. More...
 
float m_sumEz_xx [N_DRAWERS]
 Sum Ez recalculated offline using DSP raw channels. More...
 
float m_sumE_xx [N_DRAWERS]
 Sum E recalculated offline using DSP raw channels. More...
 
float m_sumEt_yy [N_DRAWERS]
 Sum Et calcualted inside DSP. More...
 
float m_sumEz_yy [N_DRAWERS]
 Sum Ez calcualted inside DSP. More...
 
float m_sumE_yy [N_DRAWERS]
 Sum E calcualted inside DSP. More...
 
float m_sumEt_zz [N_DRAWERS]
 Sum Et recalculated offline using offline OF. More...
 
float m_sumEz_zz [N_DRAWERS]
 Sum Ez recalculated offline using offline OF. More...
 
float m_sumE_zz [N_DRAWERS]
 Sum E recalculated offline using offline OF. More...
 
bool m_bad [N_ROS][N_MODULES][N_CHANS]
 
int m_skipEvents
 
std::vector< uint32_t > m_ROBID
 
ServiceHandle< TileCablingSvc > m_cablingSvc
 Name of Tile cabling service. More...
 
ServiceHandle< IROBDataProviderSvc > m_robSvc
 
ToolHandle< TileROD_Decoder > m_decoder
 
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
 
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

class to produce TileCal commissioning ntuples

Definition at line 96 of file TileAANtuple.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

◆ TileAANtuple()

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

Definition at line 112 of file TileAANtuple.cxx.

113 : AthAlgorithm(name, pSvcLocator)
114 , m_evTime(0)
115 , m_run(0)
116 , m_evt(0)
117 , m_lumiBlock(0)
118 , m_HHMMSS(0)
119 , m_dateTime()
120 , m_trigType(0)
121 , m_dspFlags(0)
122 , m_l1ID()
123 , m_l1Type()
124 , m_evBCID()
125 , m_evType()
126 , m_cispar()
127 , m_las_version(0)
128 , m_las_BCID(0)
129 , m_las_Filt(0)
130 , m_las_ReqAmp(0)
131 , m_las_MeasAmp(0)
132 , m_las_Temperature(0)
133 , m_arrays (std::make_unique<Arrays>())
134 , m_qdctimeout(0)
135 , m_tdctimeout(0)
136 , m_daqtype(0)
137 , m_nBadDr(0)
138 , m_nBadHV(0)
139 , m_nBadDCS(0)
140 , m_nBadDB(0)
141 , m_nBadTotal(0)
142 , m_rchUnit(TileRawChannelUnit::MegaElectronVolts)
143 , m_dspUnit(TileRawChannelUnit::ADCcounts)
144 , m_ntuplePtr(0)
145 , m_DCSntuplePtr(0)
146 , m_thistSvc("THistSvc", name)
147 , m_tileID(0)
148 , m_tileHWID(0)
149 , m_cabling(0)
150 , m_tileMgr(0)
151 , m_tileBadChanTool("TileBadChanTool")
152 , m_tileToolEmscale("TileCondToolEmscale")
153 , m_l2Builder()
154 , m_sumEt_xx()
155 , m_sumEz_xx()
156 , m_sumE_xx()
157 , m_sumEt_yy()
158 , m_sumEz_yy()
159 , m_sumE_yy()
160 , m_sumEt_zz()
161 , m_sumEz_zz()
162 , m_sumE_zz()
163 , m_bad()
164 {
165  declareProperty("TileCondToolEmscale", m_tileToolEmscale);
166  declareProperty("TileDigitsContainer", m_digitsContainerKey = "TileDigitsCnt");
167  declareProperty("TileDigitsContainerFlt", m_fltDigitsContainerKey = "" /* "TileDigitsFlt" */);
168  declareProperty("TileBeamElemContainer", m_beamElemContainerKey = "TileBeamElemCnt");
169  declareProperty("TileRawChannelContainer", m_rawChannelContainerKey = "TileRawChannelCnt");
170  declareProperty("TileRawChannelContainerFit", m_fitRawChannelContainerKey = ""); //
171  declareProperty("TileRawChannelContainerFitCool", m_fitcRawChannelContainerKey = ""); // don't create
172  declareProperty("TileRawChannelContainerOpt", m_optRawChannelContainerKey = ""); // by default
173  declareProperty("TileRawChannelContainerQIE", m_qieRawChannelContainerKey = ""); // processed QIE data
174  declareProperty("TileRawChannelContainerOF1", m_of1RawChannelContainerKey = ""); //
175  declareProperty("TileRawChannelContainerDsp", m_dspRawChannelContainerKey = ""); //
176  declareProperty("TileRawChannelContainerMF", m_mfRawChannelContainerKey = ""); //
177  declareProperty("TileRawChannelContainerWiener", m_wienerRawChannelContainerKey = "");//
178  declareProperty("TileMuRcvRawChannelContainer", m_tileMuRcvRawChannelContainerKey = "MuRcvRawChCnt");// TMDB
179  declareProperty("TileMuRcvDigitsContainer", m_tileMuRcvDigitsContainerKey = "MuRcvDigitsCnt");// TMDB
180  declareProperty("TileMuRcvContainer", m_tileMuRcvContainerKey = "TileMuRcvCnt");// TMDB
181  declareProperty("TileLaserObject", m_laserObjectKey = "" /* "TileLaserObj" */); //
182  declareProperty("TileL2Cnt", m_l2CntKey = "TileL2Cnt");
183  declareProperty("CalibrateEnergy", m_calibrateEnergy = true);
184  declareProperty("UseDspUnits", m_useDspUnits = false);
185  declareProperty("OfflineUnits", m_finalUnit = TileRawChannelUnit::MegaElectronVolts);
186  declareProperty("CalibMode", m_calibMode = false);
187  declareProperty("CompareMode", m_compareMode = false);
188  declareProperty("BSInput", m_bsInput = true);
189  declareProperty("PMTOrder", m_pmtOrder = false);
190 
191  declareProperty("StreamName", m_streamName = "AANT");
192  declareProperty("NTupleID", m_ntupleID = "h2000");
193  declareProperty("TreeSize", m_treeSize = 16000000000LL);
194 
195  declareProperty("CheckDCS",m_checkDCS = false);
196  declareProperty("DCSBranches",m_DCSBranches = 111111111);
197 
198  declareProperty("SkipEvents", m_skipEvents = 0);
199  declareProperty("NSamples", m_nSamples=7);
200  declareProperty("Reduced", m_reduced=false);
201  declareProperty("CompressionSettings", m_compressSettings = -1);
202 
203  m_evtNr = -1;
204 }

◆ ~TileAANtuple()

TileAANtuple::~TileAANtuple ( )
virtual

Definition at line 206 of file TileAANtuple.cxx.

206  {
207 }

Member Function Documentation

◆ CheckDMUFormat()

short TileAANtuple::CheckDMUFormat ( uint32_t  header)
inlineprivate

bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0

Definition at line 167 of file TileAANtuple.h.

167  {
168  if (((header >> 31 & 0x1) == 1) && ((header >> 17 & 0x1) == 0))
169  return 0; // no error
170  else
171  return 1; //error
172  }

◆ CheckDMUParity()

short TileAANtuple::CheckDMUParity ( uint32_t  header)
inlineprivate

Parity of the DMU header should be odd.

Definition at line 177 of file TileAANtuple.h.

177  {
178  uint32_t parity(0);
179  for (int i = 0; i < 32; ++i)
180  parity += header >> i & 0x1;
181 
182  if ((parity % 2) == 1)
183  return 0; //no error
184  else
185  return 1; //error
186  }

◆ CISPAR_addBranch()

void TileAANtuple::CISPAR_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 1683 of file TileAANtuple.cxx.

1683  {
1684  if (!m_beamElemContainerKey.key().empty()) {
1685  m_ntuplePtr->Branch("cispar",m_cispar,"cispar[110]/i");
1686  }
1687 }

◆ CISPAR_clearBranch()

void TileAANtuple::CISPAR_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variables

////////////////////////////////////////////////////////////////////////////

Definition at line 1696 of file TileAANtuple.cxx.

1696  {
1697  if (!m_beamElemContainerKey.key().empty()) {
1698  CLEAR(m_cispar);
1699  }
1700 }

◆ DCS_addBranch()

void TileAANtuple::DCS_addBranch ( void  )
private

Definition at line 2218 of file TileAANtuple.cxx.

2218  {
2219  bool br[9];
2220  int mask = m_DCSBranches;
2221 
2222  for (int i = 0; i < 9; ++i) {
2223  br[i] = (mask % 10);
2224  mask /= 10;
2225  }
2226 
2227  if (br[0]) {
2228  m_DCSntuplePtr->Branch("EvTime", &m_evTime, "EvTime/I");
2229  m_DCSntuplePtr->Branch("Run", &m_run, "Run/I");
2230  m_DCSntuplePtr->Branch("LumiBlock",&m_lumiBlock,"LumiBlock/I");
2231  m_DCSntuplePtr->Branch("HHMMSS", &m_HHMMSS, "HHMMSS/I");
2232  m_DCSntuplePtr->Branch("Evt", &m_evt, "Evt/I");
2233  m_DCSntuplePtr->Branch("EvtNr", &m_evtNr, "EvtNr/I");
2234  }
2235 
2236  if (br[1]) m_DCSntuplePtr->Branch("TEMP", m_arrays->m_TEMP, "TEMP[4][64][7]/F");
2237  if (br[2]) m_DCSntuplePtr->Branch("HV", m_arrays->m_HV, "HV[4][64][48]/F");
2238  if (br[3]) m_DCSntuplePtr->Branch("HVSET", m_arrays->m_HVSET, "HVSET[4][64][48]/F");
2239  if (br[4]) m_DCSntuplePtr->Branch("DRSTATES",m_arrays->m_DRSTATES,"DRSTATES[4][64]/I");
2240  if (br[5]) m_DCSntuplePtr->Branch("HVSTATUS",m_arrays->m_HVSTATUS,"HVSTATUS[4][64][48]/S");
2241  if (br[6]) m_DCSntuplePtr->Branch("DRSTATUS",m_arrays->m_DRSTATUS,"DRSTATUS[4][64]/S");
2242  if (br[7]) m_DCSntuplePtr->Branch("CHSTATUS",m_arrays->m_CHSTATUS,"CHSTATUS[4][64][48]/S");
2243  if (br[8]) {
2244  m_DCSntuplePtr->Branch("nBadDr", &m_nBadDr, "nBadDr/I");
2245  m_DCSntuplePtr->Branch("nBadHV", &m_nBadHV, "nBadHV/I");
2246  m_DCSntuplePtr->Branch("nBadDCS", &m_nBadDCS, "nBadDCS/I");
2247  m_DCSntuplePtr->Branch("nBadDB", &m_nBadDB, "nBadDB/I");
2248  m_DCSntuplePtr->Branch("nBadTotal", &m_nBadTotal, "nBadTotal/I");
2249  }
2250 }

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

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

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

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

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

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

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

200  {
201  return PBASE::declareProperty(t);
202  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

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

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ 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; }

◆ DIGI_addBranch()

void TileAANtuple::DIGI_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 1854 of file TileAANtuple.cxx.

1855 {
1856  std::string suf[3] = {"_lo","_hi",""};
1857  if (m_compareMode) {
1858  suf[0] = "_xx";
1859  suf[1] = "_yy";
1860  suf[2] = "_zz";
1861  m_ntuplePtr->Branch(NAME2("sumEt",suf[0]), m_sumEt_xx, NAME3("sumEt", suf[0],"[4][64]/F")); // float
1862  m_ntuplePtr->Branch(NAME2("sumEz",suf[0]), m_sumEz_xx, NAME3("sumEz", suf[0],"[4][64]/F")); // float
1863  m_ntuplePtr->Branch(NAME2("sumE", suf[0]), m_sumE_xx, NAME3("sumE", suf[0],"[4][64]/F")); // float
1864  m_ntuplePtr->Branch(NAME2("sumEt",suf[1]), m_sumEt_yy, NAME3("sumEt", suf[1],"[4][64]/F")); // float
1865  m_ntuplePtr->Branch(NAME2("sumEz",suf[1]), m_sumEz_yy, NAME3("sumEz", suf[1],"[4][64]/F")); // float
1866  m_ntuplePtr->Branch(NAME2("sumE", suf[1]), m_sumE_yy, NAME3("sumE", suf[1],"[4][64]/F")); // float
1867  m_ntuplePtr->Branch(NAME2("sumEt",suf[2]), m_sumEt_zz, NAME3("sumEt", suf[2],"[4][64]/F")); // float
1868  m_ntuplePtr->Branch(NAME2("sumEz",suf[2]), m_sumEz_zz, NAME3("sumEz", suf[2],"[4][64]/F")); // float
1869  m_ntuplePtr->Branch(NAME2("sumE", suf[2]), m_sumE_zz, NAME3("sumE", suf[2],"[4][64]/F")); // float
1870  }
1871 
1872  int sample_size = N_ROS*N_MODULES*N_CHANS*m_nSamples;
1873 
1874  int imin = 2, imax = 3, ir = 0, is = 0;
1875 
1876  if (m_calibMode) {
1877  imin = 0;
1878  imax = 2;
1879  }
1880 
1881  if (!m_mfRawChannelContainerKey.empty()) {
1882  int size = sample_size * (imax-imin);
1883  m_arrays->m_eMF = (float *) malloc(size*sizeof(float));
1884  m_arrays->m_tMF = (float *) malloc(size*sizeof(float));
1885  }
1886 
1887  for (int i = imin; i < imax; ++i) {
1888 
1889  std::string f_suf(suf[i]);
1890 
1891  if (m_fltDigitsContainerKey.empty() && m_digitsContainerKey.empty()
1892  && (!m_rawChannelContainerKey.empty()
1893  || !m_fitRawChannelContainerKey.empty()
1894  || !m_fitcRawChannelContainerKey.empty()
1895  || !m_optRawChannelContainerKey.empty()
1896  || !m_qieRawChannelContainerKey.empty()
1897  || !m_dspRawChannelContainerKey.empty()
1898  || !m_mfRawChannelContainerKey.empty()
1899  || !m_of1RawChannelContainerKey.empty()
1900  || !m_wienerRawChannelContainerKey.empty()
1901  || !m_bsInput) ) {
1902 
1903  m_ntuplePtr->Branch(NAME2("gain",f_suf), m_arrays->m_gain[ir], NAME3("gain", f_suf,"[4][64][48]/S")); // short
1904 
1905  } else {
1906 
1907  std::string samples = "[4][64][48][" + std::to_string(m_nSamples) + "]/S";
1908 
1909  if (!m_fltDigitsContainerKey.empty()) {
1910  if (!m_digitsContainerKey.empty()) { // should use different names for two containers
1911 
1912  m_ntuplePtr->Branch(NAME2("sampleFlt",f_suf), &(m_arrays->m_sample[is]), NAME3("sampleFlt", f_suf, samples)); // short
1913  m_ntuplePtr->Branch(NAME2("gainFlt",f_suf), m_arrays->m_gainFlt[ir], NAME3("gainFlt", f_suf,"[4][64][48]/S")); // short
1914  } else {
1915  m_ntuplePtr->Branch(NAME2("sample",f_suf), &(m_arrays->m_sampleFlt[is]), NAME3("sampleFlt", f_suf, samples)); // short
1916  if (!m_rawChannelContainerKey.empty()
1917  || !m_fitRawChannelContainerKey.empty()
1918  || !m_fitcRawChannelContainerKey.empty()
1919  || !m_optRawChannelContainerKey.empty()
1920  || !m_qieRawChannelContainerKey.empty()
1921  || !m_of1RawChannelContainerKey.empty()
1922  || !m_dspRawChannelContainerKey.empty()
1923  || !m_wienerRawChannelContainerKey.empty()
1924  || m_bsInput) {
1925 
1926  m_ntuplePtr->Branch(NAME2("gain",f_suf), m_arrays->m_gain[ir], NAME3("gain", f_suf,"[4][64][48]/S")); // short
1927  } else {
1928  m_ntuplePtr->Branch(NAME2("gain",f_suf), m_arrays->m_gainFlt[ir], NAME3("gainFlt", f_suf,"[4][64][48]/S")); // short
1929  }
1930  }
1931  }
1932 
1933  if (!m_digitsContainerKey.empty()) {
1934  m_ntuplePtr->Branch(NAME2("sample",f_suf), &(m_arrays->m_sample[is]), NAME3("sample", f_suf, samples)); // short
1935  m_ntuplePtr->Branch(NAME2("gain",f_suf), m_arrays->m_gain[ir], NAME3("gain", f_suf,"[4][64][48]/S")); // short
1936 
1937  if (m_bsInput) {
1938  m_ntuplePtr->Branch(NAME2("DMUheader",f_suf), m_arrays->m_DMUheader[ir], NAME3("DMUheader", f_suf,"[4][64][16]/i")); // uint32
1939  m_ntuplePtr->Branch(NAME2("DMUBCID",f_suf), m_arrays->m_DMUbcid[ir], NAME3("DMUBCID", f_suf,"[4][64][16]/S")); // short
1940  m_ntuplePtr->Branch(NAME2("DMUmemoryErr",f_suf), m_arrays->m_DMUmemoryErr[ir], NAME3("DMUmemoryErr", f_suf,"[4][64][16]/S")); // short
1941  m_ntuplePtr->Branch(NAME2("DMUSstrobeErr",f_suf), m_arrays->m_DMUSstrobeErr[ir], NAME3("DMUSstrobeErr", f_suf,"[4][64][16]/S")); // short
1942  m_ntuplePtr->Branch(NAME2("DMUDstrobeErr",f_suf), m_arrays->m_DMUDstrobeErr[ir], NAME3("DMUDstrobeErr", f_suf,"[4][64][16]/S")); // short
1943  m_ntuplePtr->Branch(NAME2("DMUheadformatErr",f_suf),m_arrays->m_DMUformatErr[ir], NAME3("DMUheadformatErr", f_suf,"[4][64][16]/S")); // short
1944  m_ntuplePtr->Branch(NAME2("DMUheadparityErr",f_suf),m_arrays->m_DMUparityErr[ir], NAME3("DMUheadparityErr", f_suf,"[4][64][16]/S")); // short
1945 
1946  m_ntuplePtr->Branch(NAME2("feCRC",f_suf), m_arrays->m_feCRC[ir], NAME3("feCRC", f_suf,"[4][64][16]/S")); // short
1947  m_ntuplePtr->Branch(NAME2("rodCRC",f_suf), m_arrays->m_rodCRC[ir], NAME3("rodCRC", f_suf,"[4][64][16]/S")); // short
1948 
1949  if (i == imin) { // common for low and high gain
1950  m_ntuplePtr->Branch("rodBCID", m_arrays->m_rodBCID, "rodBCID[4][64]/S"); // short
1951  m_ntuplePtr->Branch("fragSize", m_arrays->m_fragSize,"fragSize[4][64]/S"); // short
1952  m_ntuplePtr->Branch("DMUmask", m_arrays->m_dmuMask, "DMUmask[4][64][2]/s"); // unsigned short
1953  m_ntuplePtr->Branch("slinkCRC", m_arrays->m_slinkCRC,"slinkCRC[4][64][2]/s"); // unsigned short
1954  }
1955  }
1956  }
1957  }
1958 
1959  if (!m_rawChannelContainerKey.empty()) {
1960  m_ntuplePtr->Branch(NAME2("ene",f_suf), m_arrays->m_ene[ir], NAME3("ene",f_suf,"[4][64][48]/F")); // float
1961  m_ntuplePtr->Branch(NAME2("time",f_suf), m_arrays->m_time[ir], NAME3("time",f_suf,"[4][64][48]/F")); // float
1962  m_ntuplePtr->Branch(NAME2("ped",f_suf), m_arrays->m_ped[ir], NAME3("ped",f_suf,"[4][64][48]/F")); // float
1963  m_ntuplePtr->Branch(NAME2("chi2",f_suf), m_arrays->m_chi2[ir], NAME3("chi2",f_suf,"[4][64][48]/F")); // float
1964  }
1965 
1966  if (!m_fitRawChannelContainerKey.empty()) {
1967  m_ntuplePtr->Branch(NAME2("eFit",f_suf), m_arrays->m_eFit[ir], NAME3("eFit",f_suf,"[4][64][48]/F")); // float
1968  m_ntuplePtr->Branch(NAME2("tFit",f_suf), m_arrays->m_tFit[ir], NAME3("tFit",f_suf,"[4][64][48]/F")); // float
1969  m_ntuplePtr->Branch(NAME2("pedFit",f_suf), m_arrays->m_pedFit[ir], NAME3("pedFit",f_suf,"[4][64][48]/F")); // float
1970  m_ntuplePtr->Branch(NAME2("chi2Fit",f_suf), m_arrays->m_chi2Fit[ir], NAME3("chi2Fit",f_suf,"[4][64][48]/F")); // float
1971  }
1972 
1973  if (!m_fitcRawChannelContainerKey.empty()) {
1974  m_ntuplePtr->Branch(NAME2("eFitc",f_suf), m_arrays->m_eFitc[ir], NAME3("eFitc",f_suf,"[4][64][48]/F")); // float
1975  m_ntuplePtr->Branch(NAME2("tFitc",f_suf), m_arrays->m_tFitc[ir], NAME3("tFitc",f_suf,"[4][64][48]/F")); // float
1976  m_ntuplePtr->Branch(NAME2("pedFitc",f_suf), m_arrays->m_pedFitc[ir], NAME3("pedFitc",f_suf,"[4][64][48]/F")); // float
1977  m_ntuplePtr->Branch(NAME2("chi2Fitc",f_suf),m_arrays->m_chi2Fitc[ir],NAME3("chi2Fitc",f_suf,"[4][64][48]/F")); // float
1978  }
1979 
1980  if (!m_optRawChannelContainerKey.empty()) {
1981  m_ntuplePtr->Branch(NAME2("eOpt",f_suf), m_arrays->m_eOpt[ir], NAME3("eOpt",f_suf,"[4][64][48]/F")); // float
1982  m_ntuplePtr->Branch(NAME2("tOpt",f_suf), m_arrays->m_tOpt[ir], NAME3("tOpt",f_suf,"[4][64][48]/F")); // float
1983  m_ntuplePtr->Branch(NAME2("pedOpt",f_suf), m_arrays->m_pedOpt[ir], NAME3("pedOpt",f_suf,"[4][64][48]/F")); // float
1984  m_ntuplePtr->Branch(NAME2("chi2Opt",f_suf), m_arrays->m_chi2Opt[ir], NAME3("chi2Opt",f_suf,"[4][64][48]/F")); // float
1985  }
1986 
1987  if (!m_qieRawChannelContainerKey.empty()) {
1988  m_ntuplePtr->Branch(NAME2("eQIE",f_suf), m_arrays->m_eQIE[ir], NAME3("eQIE",f_suf,"[4][64][48]/F")); // float
1989  m_ntuplePtr->Branch(NAME2("tQIE",f_suf), m_arrays->m_tQIE[ir], NAME3("tQIE",f_suf,"[4][64][48]/F")); // float
1990  m_ntuplePtr->Branch(NAME2("pedQIE",f_suf), m_arrays->m_pedQIE[ir], NAME3("pedQIE",f_suf,"[4][64][48]/F")); // float
1991  m_ntuplePtr->Branch(NAME2("chi2QIE",f_suf), m_arrays->m_chi2QIE[ir], NAME3("chi2QIE",f_suf,"[4][64][48]/F")); // float
1992  }
1993 
1994  if (!m_of1RawChannelContainerKey.empty()) {
1995  m_ntuplePtr->Branch(NAME2("eOF1",f_suf), m_arrays->m_eOF1[ir], NAME3("eOF1",f_suf,"[4][64][48]/F")); // float
1996  m_ntuplePtr->Branch(NAME2("tOF1",f_suf), m_arrays->m_tOF1[ir], NAME3("tOF1",f_suf,"[4][64][48]/F")); // float
1997  m_ntuplePtr->Branch(NAME2("pedOF1",f_suf), m_arrays->m_pedOF1[ir], NAME3("pedOF1",f_suf,"[4][64][48]/F")); // float
1998  m_ntuplePtr->Branch(NAME2("chi2OF1",f_suf), m_arrays->m_chi2OF1[ir], NAME3("chi2OF1",f_suf,"[4][64][48]/F")); // float
1999  }
2000 
2001  if (!m_dspRawChannelContainerKey.empty() && !m_reduced) {
2002  m_ntuplePtr->Branch(NAME2("eDsp",f_suf), m_arrays->m_eDsp[ir], NAME3("eDsp",f_suf,"[4][64][48]/F")); // float
2003  m_ntuplePtr->Branch(NAME2("tDsp",f_suf), m_arrays->m_tDsp[ir], NAME3("tDsp",f_suf,"[4][64][48]/F")); // float
2004  m_ntuplePtr->Branch(NAME2("pedDsp",f_suf), m_arrays->m_pedDsp[ir], NAME3("pedDsp",f_suf,"[4][64][48]/F")); // float
2005  m_ntuplePtr->Branch(NAME2("chi2Dsp",f_suf), m_arrays->m_chi2Dsp[ir], NAME3("chi2Dsp",f_suf,"[4][64][48]/F")); // float
2006  }
2007 
2008  if (!m_wienerRawChannelContainerKey.empty()) {
2009  m_ntuplePtr->Branch(NAME2("eWiener",f_suf), m_arrays->m_eWiener[ir], NAME3("eWiener",f_suf,"[4][64][48]/F")); // float
2010  m_ntuplePtr->Branch(NAME2("tWiener",f_suf), m_arrays->m_tWiener[ir], NAME3("tWiener",f_suf,"[4][64][48]/F")); // float
2011  m_ntuplePtr->Branch(NAME2("pedWiener",f_suf), m_arrays->m_pedWiener[ir], NAME3("pedWiener",f_suf,"[4][64][48]/F")); // float
2012  m_ntuplePtr->Branch(NAME2("chi2Wiener",f_suf), m_arrays->m_chi2Wiener[ir], NAME3("chi2Wiener",f_suf,"[4][64][48]/F")); // float
2013  }
2014 
2015  if (!m_mfRawChannelContainerKey.empty()) {
2016  std::string f_samples = "[4][64][48][" + std::to_string(m_nSamples) + "]/F";
2017  m_ntuplePtr->Branch(NAME2("eMF",f_suf), &(m_arrays->m_eMF[is]), NAME3("eMF",f_suf,f_samples)); // float
2018  m_ntuplePtr->Branch(NAME2("tMF",f_suf), &(m_arrays->m_tMF[is]), NAME3("tMF",f_suf,f_samples)); // float
2019  m_ntuplePtr->Branch(NAME2("chi2MF",f_suf), m_arrays->m_chi2MF[ir], NAME3("chi2MF",f_suf,"[4][64][48]/F")); // float
2020  m_ntuplePtr->Branch(NAME2("pedMF",f_suf), m_arrays->m_pedMF[ir], NAME3("pedMF",f_suf,"[4][64][48]/F")); // float
2021  }
2022 
2023  if (m_bsInput) {
2024  if (i == imin) { // common for low and high gain
2025  m_ntuplePtr->Branch("ROD_GlobalCRC", m_arrays->m_ROD_GlobalCRC, "ROD_GlobalCRC[4][64]/S"); // short
2026  m_ntuplePtr->Branch("ROD_BCID", m_arrays->m_ROD_BCID, "ROD_BCID[4][64]/S"); // short
2027  m_ntuplePtr->Branch("ROD_DMUBCIDErr", m_arrays->m_ROD_DMUBCIDErr, "ROD_DMUBCIDErr[4][64][16]/S"); // short
2028  m_ntuplePtr->Branch("ROD_DMUmemoryErr", m_arrays->m_ROD_DMUmemoryErr, "ROD_DMUmemoryErr[4][64][16]/S"); // short
2029  m_ntuplePtr->Branch("ROD_DMUSstrobeErr", m_arrays->m_ROD_DMUSstrobeErr, "ROD_DMUSstrobeErr[4][64][16]/S"); // short
2030  m_ntuplePtr->Branch("ROD_DMUDstrobeErr", m_arrays->m_ROD_DMUDstrobeErr, "ROD_DMUDstrobeErr[4][64][16]/S"); // short
2031  m_ntuplePtr->Branch("ROD_DMUheadformatErr",m_arrays->m_ROD_DMUHeadformatErr, "ROD_DMUheadformatErr[4][64][16]/S"); // short
2032  m_ntuplePtr->Branch("ROD_DMUheadparityErr",m_arrays->m_ROD_DMUHeadparityErr, "ROD_DMUheadparityErr[4][64][16]/S"); // short
2033  m_ntuplePtr->Branch("ROD_DMUdataformatErr",m_arrays->m_ROD_DMUDataformatErr, "ROD_DMUdataformatErr[4][64][16]/S"); // short
2034  m_ntuplePtr->Branch("ROD_DMUdataparityErr",m_arrays->m_ROD_DMUDataparityErr, "ROD_DMUdataparityErr[4][64][16]/S"); // short
2035 
2036  m_ntuplePtr->Branch("ROD_feCRC", m_arrays->m_ROD_DMUfeCRC, "ROD_feCRC[4][64][16]/S"); // short
2037  m_ntuplePtr->Branch("ROD_rodCRC", m_arrays->m_ROD_DMUrodCRC, "ROD_rodCRC[4][64][16]/S"); // short
2038  m_ntuplePtr->Branch("ROD_DMUmask", m_arrays->m_ROD_DMUMask, "ROD_DMUmask[4][64][2]/s"); // unsigned short
2039  }
2040  }
2041  ir += N_ROS;
2042  is += sample_size;
2043  }
2044 }

◆ DIGI_clearBranch()

void TileAANtuple::DIGI_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variables ////////////////////////////////////////////////////////////////////////////

Definition at line 2051 of file TileAANtuple.cxx.

2051  {
2052  unsigned int size = (m_calibMode) ? 1 : 2;
2053 
2054  if (m_compareMode) {
2055  CLEAR(m_sumEt_xx);
2056  CLEAR(m_sumEt_yy);
2057  CLEAR(m_sumEt_zz);
2058  CLEAR(m_sumEz_xx);
2059  CLEAR(m_sumEz_yy);
2060  CLEAR(m_sumEz_zz);
2061  CLEAR(m_sumE_xx);
2062  CLEAR(m_sumE_yy);
2063  CLEAR(m_sumE_zz);
2064  }
2065 
2066  CLEAR3(m_arrays->m_gain, size);
2067 
2068  if (!m_fltDigitsContainerKey.empty()) {
2069  CLEAR5(m_arrays->m_sampleFlt, size);
2070  CLEAR3(m_arrays->m_gainFlt, size);
2071  }
2072 
2073  if (!m_digitsContainerKey.empty()) {
2074 
2075  CLEAR5(m_arrays->m_sample,size);
2076 
2077  if (m_bsInput) {
2078  CLEAR2(m_arrays->m_DMUheader, size);
2079  CLEAR3(m_arrays->m_DMUbcid, size);
2080  CLEAR3(m_arrays->m_DMUformatErr, size);
2081  CLEAR3(m_arrays->m_DMUparityErr, size);
2082  CLEAR3(m_arrays->m_DMUmemoryErr, size);
2083  CLEAR3(m_arrays->m_DMUSstrobeErr, size);
2084  CLEAR3(m_arrays->m_DMUDstrobeErr, size);
2085 
2086  CLEAR3(m_arrays->m_feCRC, size);
2087  CLEAR3(m_arrays->m_rodCRC, size);
2088 
2089  CLEAR1(m_arrays->m_rodBCID);
2090  CLEAR1(m_arrays->m_fragSize);
2091  CLEAR(m_arrays->m_dmuMask);
2092  CLEAR(m_arrays->m_slinkCRC);
2093  }
2094 
2095  }
2096 
2097  if (!m_rawChannelContainerKey.empty()) {
2098  CLEAR2(m_arrays->m_ene, size);
2099  CLEAR2(m_arrays->m_time, size);
2100  CLEAR2(m_arrays->m_ped, size);
2101  CLEAR2(m_arrays->m_chi2, size);
2102  }
2103 
2104  if (!m_fitRawChannelContainerKey.empty()) {
2105  CLEAR2(m_arrays->m_eFit, size);
2106  CLEAR2(m_arrays->m_tFit, size);
2107  CLEAR2(m_arrays->m_pedFit, size);
2108  CLEAR2(m_arrays->m_chi2Fit, size);
2109  }
2110 
2111  if (!m_fitcRawChannelContainerKey.empty()) {
2112  CLEAR2(m_arrays->m_eFitc, size);
2113  CLEAR2(m_arrays->m_tFitc, size);
2114  CLEAR2(m_arrays->m_pedFitc, size);
2115  CLEAR2(m_arrays->m_chi2Fitc, size);
2116  }
2117 
2118  if (!m_optRawChannelContainerKey.empty()) {
2119  CLEAR2(m_arrays->m_eOpt, size);
2120  CLEAR2(m_arrays->m_tOpt, size);
2121  CLEAR2(m_arrays->m_pedOpt, size);
2122  CLEAR2(m_arrays->m_chi2Opt, size);
2123  }
2124 
2125 
2126  if (!m_qieRawChannelContainerKey.empty()) {
2127  CLEAR2(m_arrays->m_eQIE, size);
2128  CLEAR2(m_arrays->m_tQIE, size);
2129  CLEAR2(m_arrays->m_pedQIE, size);
2130  CLEAR2(m_arrays->m_chi2QIE, size);
2131  }
2132 
2133  if (!m_of1RawChannelContainerKey.empty()) {
2134  CLEAR2(m_arrays->m_eOF1, size);
2135  CLEAR2(m_arrays->m_tOF1, size);
2136  CLEAR2(m_arrays->m_pedOF1, size);
2137  CLEAR2(m_arrays->m_chi2OF1, size);
2138  }
2139 
2140  if (!m_dspRawChannelContainerKey.empty()) {
2141  CLEAR2(m_arrays->m_eDsp, size);
2142  CLEAR2(m_arrays->m_tDsp, size);
2143  CLEAR2(m_arrays->m_pedDsp, size);
2144  CLEAR2(m_arrays->m_chi2Dsp, size);
2145  }
2146 
2147  if (!m_mfRawChannelContainerKey.empty()) {
2148  CLEAR4(m_arrays->m_eMF, size);
2149  CLEAR4(m_arrays->m_tMF, size);
2150  CLEAR2(m_arrays->m_chi2MF, size);
2151  CLEAR2(m_arrays->m_pedMF, size);
2152  }
2153 
2154  if (!m_wienerRawChannelContainerKey.empty()) {
2155  CLEAR2(m_arrays->m_eWiener, size);
2156  CLEAR2(m_arrays->m_tWiener, size);
2157  CLEAR2(m_arrays->m_pedWiener, size);
2158  CLEAR2(m_arrays->m_chi2Wiener, size);
2159  }
2160 
2161  if (m_bsInput) {
2162  CLEAR1(m_arrays->m_ROD_GlobalCRC);
2163  CLEAR1(m_arrays->m_ROD_BCID);
2164  CLEAR1(m_arrays->m_ROD_DMUBCIDErr);
2165  CLEAR1(m_arrays->m_ROD_DMUmemoryErr);
2166  CLEAR1(m_arrays->m_ROD_DMUSstrobeErr);
2167  CLEAR1(m_arrays->m_ROD_DMUDstrobeErr);
2168  CLEAR1(m_arrays->m_ROD_DMUHeadformatErr);
2169  CLEAR1(m_arrays->m_ROD_DMUHeadparityErr);
2170  CLEAR1(m_arrays->m_ROD_DMUDataformatErr);
2171  CLEAR1(m_arrays->m_ROD_DMUDataparityErr);
2172  CLEAR1(m_arrays->m_ROD_DMUfeCRC);
2173  CLEAR1(m_arrays->m_ROD_DMUrodCRC);
2174  CLEAR(m_arrays->m_ROD_DMUMask);
2175  }
2176 
2177 }

◆ digiChannel2PMT()

int TileAANtuple::digiChannel2PMT ( int  fragType,
int  chan 
)
inlineprivate

Definition at line 161 of file TileAANtuple.h.

161  {
162  return (abs(m_cabling->channel2hole(fragType, chan)) - 1);
163  }

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

Definition at line 332 of file TileAANtuple.cxx.

332  {
333  const EventContext& ctx = Gaudi::Hive::currentContext();
334  const TileDQstatus* DQstatus = SG::makeHandle (m_DQstatusKey, ctx).get();
335 
336  if (m_evtNr < 0) {
337  if (ntuple_initialize(ctx, *DQstatus).isFailure()) {
338  ATH_MSG_ERROR( "ntuple_initialize failed" );
339  }
340  }
341 
342  if (m_evtNr%1000 == 0) {
343  ATH_MSG_INFO( m_evtNr << " events processed so far" );
344  }
345 
346  if (ntuple_clear().isFailure()) {
347  ATH_MSG_ERROR( "ntuple_clear failed" );
348  }
349 
350  bool empty = true;
351 
352  // store BeamElements
353  if (!m_beamElemContainerKey.key().empty()) {
354  empty &= storeBeamElements(*DQstatus).isFailure();
355  }
356 
357  //store Laser Object
358  if (!m_laserObjectKey.empty()) {
359  empty &= storeLaser(ctx).isFailure();
360  }
361 
362  // store TileDigits
363  empty &= storeDigits(ctx, m_fltDigitsContainerKey,m_arrays->m_sampleFlt,m_arrays->m_gainFlt,false).isFailure();
364  empty &= storeDigits(ctx, m_digitsContainerKey, m_arrays->m_sample, m_arrays->m_gain, true ).isFailure();
365 
366  // store TileRawChannels
367  // start from DSP channels - so we can find out what is the DSP units
368  empty &= storeRawChannels(ctx, m_dspRawChannelContainerKey, m_arrays->m_eDsp, m_arrays->m_tDsp, m_arrays->m_chi2Dsp, m_arrays->m_pedDsp, true ).isFailure();
369  empty &= storeRawChannels(ctx, m_rawChannelContainerKey, m_arrays->m_ene, m_arrays->m_time, m_arrays->m_chi2, m_arrays->m_ped, false).isFailure();
370  empty &= storeMFRawChannels(ctx, m_mfRawChannelContainerKey, m_arrays->m_eMF, m_arrays->m_tMF, m_arrays->m_chi2MF, m_arrays->m_pedMF, false).isFailure();
371  empty &= storeRawChannels(ctx, m_fitRawChannelContainerKey, m_arrays->m_eFit, m_arrays->m_tFit, m_arrays->m_chi2Fit, m_arrays->m_pedFit, false).isFailure();
372  empty &= storeRawChannels(ctx, m_fitcRawChannelContainerKey, m_arrays->m_eFitc, m_arrays->m_tFitc, m_arrays->m_chi2Fitc, m_arrays->m_pedFitc, false).isFailure();
373  empty &= storeRawChannels(ctx, m_optRawChannelContainerKey, m_arrays->m_eOpt, m_arrays->m_tOpt, m_arrays->m_chi2Opt, m_arrays->m_pedOpt, false).isFailure();
374  empty &= storeRawChannels(ctx, m_qieRawChannelContainerKey, m_arrays->m_eQIE, m_arrays->m_tQIE, m_arrays->m_chi2QIE, m_arrays->m_pedQIE, false).isFailure();
375  empty &= storeRawChannels(ctx, m_of1RawChannelContainerKey, m_arrays->m_eOF1, m_arrays->m_tOF1, m_arrays->m_chi2OF1, m_arrays->m_pedOF1, false).isFailure();
376  empty &= storeRawChannels(ctx, m_wienerRawChannelContainerKey, m_arrays->m_eWiener, m_arrays->m_tWiener, m_arrays->m_chi2Wiener, m_arrays->m_pedWiener, false).isFailure();
377 
378  // store TMDB data
379  //
380  empty &= storeTMDBDecision(ctx).isFailure();
381  empty &= storeTMDBDigits(ctx).isFailure();
382  empty &= storeTMDBRawChannel(ctx).isFailure();
383 
384  m_evTime = 0;
385 
386  if (m_bsInput) {
387  const eformat::FullEventFragment<const uint32_t*>* event = nullptr;
388  const eformat::ROBFragment<const uint32_t*>* robFrag = nullptr;
389  event = m_robSvc->getEvent(ctx);
390  std::vector<const ROBDataProviderSvc::ROBF*> robf;
391  // keep pointer to whole event and to CIS PAR frag internally
392  m_robSvc->getROBData(ctx, m_ROBID, robf);
393  robFrag = (robf.size() > 0 ) ? robf[0] : nullptr;
394  if (event) {
395  m_evTime = event->bc_time_seconds();
396  if ( robFrag ) {
397  // Store ROD header info from collection
398  int rod = N_RODS-1;
399  m_l1ID[rod] = robFrag->rod_lvl1_id();
400  m_l1Type[rod] = robFrag->rod_lvl1_trigger_type();
401  m_evType[rod] = robFrag->rod_detev_type();
402  m_evBCID[rod] = robFrag->rod_bc_id();
403  if (m_trigType == 0) m_trigType = -m_l1Type[rod]; // make negative to distinguish from TileCal internal trig types
404  }
405  }
406  }
407 
408  m_lumiBlock = -1; // placeholder
409 
410  //Get run and event numbers
411  m_run = ctx.eventID().run_number();
412  m_evt = ctx.eventID().event_number();
413 
414  if ( ctx.eventID().lumi_block() ){
415  m_lumiBlock = ctx.eventID().lumi_block();
416  }
417 
418  //Get timestamp of the event
419  if (ctx.eventID().time_stamp() > 0) {
420  m_evTime = ctx.eventID().time_stamp();
421  }
422 
423  if (m_evTime>0) {
424  using namespace boost::local_time;
425  using namespace boost::posix_time;
426 
427  /*
428  // just an example how to read file with time zones
429  tz_database tz_db;
430  try {
431  tz_db.load_from_file("../data/date_time_zonespec.csv");
432  time_zone_ptr gva_tz = tz_db.time_zone_from_region("Europe/Zurich");
433  }catch(data_not_accessible dna) {
434  std::cerr << "Error with time zone data file: " << dna.what() << std::endl;
435  //exit(EXIT_FAILURE);
436  }catch(bad_field_count bfc) {
437  std::cerr << "Error with time zone data file: " << bfc.what() << std::endl;
438  //exit(EXIT_FAILURE);
439  }
440  */
441  //"Europe/Zurich","CET","CET","CEST","CEST","+01:00:00","+01:00:00","-1;0;3","+02:00:00","-1;0;10","+03:00:00"
442  static const time_zone_ptr gva_tz(new posix_time_zone((std::string)"CET+01CEST01:00:00,M3.5.0/02:00:00,M10.5.0/03:00:00"));
443  local_date_time gva_time(from_time_t(m_evTime),gva_tz);
444 
445  //std::ostringstream otime;
446  //otime << gva_time; // time in the format YYYY-MMM-DD HH:MM:SS TZ
447  //strncpy(m_dateTime,otime.str().c_str(),31);
448 
449  //time_duration hms(gva_time.time_of_day()); - will give time of the day in GMT
450  //m_HHMMSS = hms.hours()*10000+hms.minutes()*100+hms.seconds();
451 
452  struct tm gva_tm(to_tm(gva_time));
453  strftime(m_dateTime, 32, "%Y-%b-%d %H:%M:%S %Z", &gva_tm);
454  m_HHMMSS = gva_tm.tm_hour*10000+gva_tm.tm_min*100+gva_tm.tm_sec;
455 
456  // the code below is only valid when running at CERN (in Geneva time zone)
457  //struct tm *time = localtime((time_t*)(&m_evTime));
458  //m_HHMMSS = time->tm_hour*10000+time->tm_min*100+time->tm_sec;
459  //strftime(m_dateTime, 32, "%Y-%m-%d %H:%M:%S %Z", time);
460 
461  } else {
462  m_HHMMSS = -1;
463  m_dateTime[0] = '\0'; // empty string
464  }
465 
466  // store DCS data
467  if (m_checkDCS) {
468  empty &= storeDCS().isFailure();
469  }
470 
471  if (empty) {
472  ATH_MSG_WARNING( "Some problems in execute - ntuple was not filled at all" );
473  }
474 
475  // FIRST 4 EVENTS ARE SKIPPED TO RETRIEVE LASER PEDESTALS
476  if (m_ntuplePtr && m_evtNr >= m_skipEvents){
477  m_ntuplePtr->Fill();
478  } // IF
479 
480  ++m_evtNr;
481 
482  // Execution completed.
483 
484  ATH_MSG_DEBUG( "execute() completed successfully" );
485  return StatusCode::SUCCESS;
486 }

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

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

◆ fillCellMap()

void TileAANtuple::fillCellMap ( TTree *  ntuplePtr)
private

///////////////////////////////////////////////////////////////////////////

/ Variables Legenda / / - C : a character string terminated by the 0 character / - B : an 8 bit signed integer / - b : an 8 bit unsigned integer 2^8=256 / - S : a 16 bit signed integer (i.e. a "short") / - s : a 16 bit unsigned integer 2^16=65536 / - I : a 32 bit signed integer (i.e an "int") / - i : a 32 bit unsigned integer 2^32=4294967296 / - F : a 32 bit floating point (i.e. a "float") / - D : a 64 bit floating point (i.e. a "double") / - L : a 64 bit signed integer / - l : a 64 bit unsigned integer / - O : a boolean //////////////////////////////////////////////////////////////////////////// /Create eta-phi map for all channels

////////////////////////////////////////////////////////////////////////////

< Pointer to MbtsDetDescrManager

Definition at line 1534 of file TileAANtuple.cxx.

1534  {
1535 
1536  float eta[4][64][48];
1537  float phi[4][64][48];
1538  short tower[4][64][48];
1539  short sample[4][64][48];
1540  short ind[4][64][48];
1541  short pmt[4][64][48];
1542  short bad[4][64][48][2];
1543 
1544  CLEAR(eta);
1545  CLEAR(phi);
1546  CLEAR1(tower);
1547  CLEAR1(sample);
1548  CLEAR1(ind);
1549  CLEAR(pmt);
1550  CLEAR1(bad);
1551 
1552  ntuplePtr->Branch("eta", eta, "eta[4][64][48]/F");
1553  ntuplePtr->Branch("phi", phi, "phi[4][64][48]/F");
1554  ntuplePtr->Branch("tower", tower, "tower[4][64][48]/S");
1555  ntuplePtr->Branch("sample", sample, "sample[4][64][48]/S");
1556  ntuplePtr->Branch("ind", ind, "ind[4][64][48]/S");
1557  ntuplePtr->Branch("pmt", pmt, "pmt[4][64][48]/S");
1558  ntuplePtr->Branch("bad", bad, "bad[4][64][48][2]/S");
1559 
1560  TileDetDescrManager::calo_element_const_iterator itr = m_tileMgr->tile_cell_begin();
1561  TileDetDescrManager::calo_element_const_iterator end = m_tileMgr->tile_cell_end();
1562 
1563  for (; itr != end; ++itr) {
1564  const CaloDetDescrElement * caloDDE = (*itr);
1565  Identifier cell_id = caloDDE->identify();
1566  IdentifierHash hash[2] = { caloDDE->onl1(), caloDDE->onl2() };
1567  for (int i = 0; i < 2; ++i) {
1568  if (hash[i] != TileHWID::NOT_VALID_HASH) {
1569  HWIdentifier adc_id = m_tileHWID->adc_id(hash[i], 0);
1570  int ROS = m_tileHWID->ros(adc_id);
1571  int drawer = m_tileHWID->drawer(adc_id);
1572  int chan = m_tileHWID->channel(adc_id);
1573  int index, pm;
1574  m_cabling->h2s_cell_id_index(adc_id, index, pm); // index=-2 for MBTS or -1 for all disconnected channels
1575  if (index > -1) index = i; // just put back 0 or 1 for all connected channels
1576  pm = m_cabling->channel2hole(ROS, chan); // convert channel to PMT number, ignoring difference between drawers
1577  if ((ROS == 3 && drawer == 14) || (ROS == 4 && drawer == 17)) {
1578  if (pm < 0) pm = -pm; // crack scin in EBA15 EBC18 in non-standard place - recover positive pmt number
1579  if (chan == 2 || chan == 3) pm = -pm; // no D4 in special EBA15 EBC18 - put negative sign
1580  }
1581  if (m_pmtOrder) chan = digiChannel2PMT(ROS,chan); // convert channel to PMT-1
1582  int rosI = ROS-1; // make ros index from 0 to 3
1583  eta[rosI][drawer][chan] = caloDDE->eta();
1584  phi[rosI][drawer][chan] = caloDDE->phi();
1585  tower[rosI][drawer][chan] = m_tileID->tower(cell_id);
1586  sample[rosI][drawer][chan] = m_tileID->sample(cell_id);
1587  ind[rosI][drawer][chan] = index;
1588  pmt[rosI][drawer][chan] = pm;
1589  }
1590  }
1591  }
1592 
1593  const MbtsDetDescrManager* mbtsMgr;
1594  if ( detStore()->retrieve(mbtsMgr).isFailure() ) {
1595  ATH_MSG_WARNING( "Unable to retrieve MbtsDetDescrManager from DetectorStore" );
1596  mbtsMgr = 0;
1597  }
1598  for (int ROS = 1; ROS < 5; ++ROS) {
1599  int rosI = ROS - 1;
1600  for (int drawer = 0; drawer < 64; ++drawer) {
1601  for (int chan = 0; chan < 48; ++chan) {
1602  for (int adc = 0; adc < 2; ++adc) {
1603  HWIdentifier adc_id = m_tileHWID->adc_id(ROS, drawer, chan, adc);
1604  bad[rosI][drawer][chan][adc] = (short) m_tileBadChanTool->encodeStatus(m_tileBadChanTool->getAdcStatus(adc_id));
1605  int index, pm;
1606  Identifier cell_id = m_cabling->h2s_cell_id_index(adc_id, index, pm);
1607  if (index == -2) { // MBTS
1608  ind[rosI][drawer][chan] = index;
1609  pmt[rosI][drawer][chan] = 1; // we know that all MBTS are in PMT 1
1610  if (mbtsMgr) {
1611  const CaloDetDescrElement * caloDDE = mbtsMgr->get_element(cell_id);
1612  if (caloDDE) {
1613  if (caloDDE->z() > 0.0)
1614  eta[rosI][drawer][chan] = fabs(caloDDE->eta());
1615  else
1616  eta[rosI][drawer][chan] = -fabs(caloDDE->eta());
1617  phi[rosI][drawer][chan] = caloDDE->phi();
1618  }
1619  }
1620  }
1621  }
1622  }
1623  }
1624  }
1625 
1626  ntuplePtr->Fill();
1627 }

◆ finalize()

StatusCode TileAANtuple::finalize ( )

Definition at line 1424 of file TileAANtuple.cxx.

1424  {
1425 
1426  if (m_arrays->m_sample) free(m_arrays->m_sample);
1427  if (m_arrays->m_sampleFlt) free(m_arrays->m_sampleFlt);
1428  if (m_arrays->m_sampleTMDB) free(m_arrays->m_sampleTMDB);
1429  if (m_arrays->m_eMF) free(m_arrays->m_eMF);
1430  if (m_arrays->m_tMF) free(m_arrays->m_tMF);
1431 
1432  ATH_MSG_INFO( "finalize() successfully" );
1433  return StatusCode::SUCCESS;
1434 }

◆ initialize()

StatusCode TileAANtuple::initialize ( )

Alg standard interface function.

Definition at line 210 of file TileAANtuple.cxx.

210  {
211  ATH_MSG_INFO( "Initialization started");
212 
213  //=== get TileCablingSvc
214  ATH_CHECK( m_cablingSvc.retrieve() );
215 
216  // find TileCablingService
217  m_cabling = TileCablingService::getInstance();
218 
219  // retrieve TileDetDescr Manager det store
220  ATH_CHECK( detStore()->retrieve(m_tileMgr) );
221 
222  // retrieve TileID helper from det store
223  ATH_CHECK( detStore()->retrieve(m_tileID) );
224  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
225 
226  //=== get TileDCSTool
227  if (m_checkDCS) {
228  ATH_CHECK( m_tileDCS.retrieve() );
229  } else {
230  m_tileDCS.disable();
231  }
232 
233  //=== get TileBadChanTool
234  ATH_CHECK( m_tileBadChanTool.retrieve() );
235 
236  //=== get TileCondToolEmscale
237  ATH_CHECK( m_tileToolEmscale.retrieve() );
238 
239  //=== get TileL2Builder
240  if (m_compareMode) {
241  ATH_CHECK( m_l2Builder.retrieve() );
242  }
243 
244  ATH_CHECK( m_DQstatusKey.initialize() );
245 
246  int sample_size = N_ROS2*N_MODULES*N_CHANS*m_nSamples;
247  int sample_TMDB_size = N_ROS*N_MODULES*N_TMDBCHANS*m_nSamples;
248  m_arrays->m_sample = (short *) malloc(sample_size*sizeof(short));
249  m_arrays->m_sampleFlt = (short *) malloc(sample_size*sizeof(short));
250  m_arrays->m_sampleTMDB = (unsigned char *) malloc(sample_TMDB_size*sizeof(unsigned char));
251 
252  ATH_CHECK( m_beamElemContainerKey.initialize(m_bsInput) );
253  ATH_CHECK( m_digitsContainerKey.initialize(SG::AllowEmpty) );
254  ATH_CHECK( m_fltDigitsContainerKey.initialize(SG::AllowEmpty) );
255  ATH_CHECK( m_laserObjectKey.initialize(SG::AllowEmpty) );
256  ATH_CHECK( m_tileMuRcvContainerKey.initialize(SG::AllowEmpty) );
257  ATH_CHECK( m_tileMuRcvDigitsContainerKey.initialize(SG::AllowEmpty) );
258  ATH_CHECK( m_tileMuRcvRawChannelContainerKey.initialize(SG::AllowEmpty) );
259  ATH_CHECK( m_mfRawChannelContainerKey.initialize(SG::AllowEmpty) );
260  ATH_CHECK( m_rawChannelContainerKey.initialize(SG::AllowEmpty) );
261  ATH_CHECK( m_fitRawChannelContainerKey.initialize(SG::AllowEmpty) );
262  ATH_CHECK( m_fitcRawChannelContainerKey.initialize(SG::AllowEmpty) );
263  ATH_CHECK( m_optRawChannelContainerKey.initialize(SG::AllowEmpty) );
264  ATH_CHECK( m_qieRawChannelContainerKey.initialize(SG::AllowEmpty) );
265  ATH_CHECK( m_dspRawChannelContainerKey.initialize(SG::AllowEmpty) );
266  ATH_CHECK( m_of1RawChannelContainerKey.initialize(SG::AllowEmpty) );
267  ATH_CHECK( m_wienerRawChannelContainerKey.initialize(SG::AllowEmpty) );
268  ATH_CHECK( m_l2CntKey.initialize(m_compareMode) );
269 
270  ATH_MSG_INFO( "initialization completed" ) ;
271  return StatusCode::SUCCESS;
272 }

◆ initNTuple()

StatusCode TileAANtuple::initNTuple ( const EventContext &  ctx)
private

Definition at line 1449 of file TileAANtuple.cxx.

1449  {
1450  //Aux Ntuple creation
1451 
1452  if (m_compressSettings >= 0) {
1453  std::vector<std::string> files;
1454  m_fileMgr->getFiles(Io::ROOT, ( Io::WRITE | Io::CREATE ), files);
1455  for (std::string& file : files) {
1456  TFile* outFile = (TFile*) m_fileMgr->fptr(file);
1457  if (outFile) {
1458  ATH_MSG_INFO("Changing compressing settings to " << m_compressSettings << " for file: " << file);
1459  outFile->SetCompressionSettings(m_compressSettings);
1460  }
1461  }
1462  }
1463 
1464  if (m_ntupleID.size() > 0) {
1465 
1466  std::string ntupleID = m_ntupleID + "_map";
1467 
1468  TTree* ntuplePtr = new TTree(ntupleID.c_str(), "TileCal-CellMap");
1469  if(m_thistSvc->regTree("/" + m_streamName + "/" + ntupleID, ntuplePtr).isFailure()) {
1470  ATH_MSG_ERROR( "Problem registering TileRec CellMap Tree" );
1471  }
1472 
1473  fillCellMap(ntuplePtr);
1474 
1475  //Ntuple creation
1476  m_ntuplePtr = new TTree(m_ntupleID.c_str(), "TileCal-Ntuple");
1477  m_ntuplePtr->SetMaxTreeSize(m_treeSize);
1478  if (m_thistSvc->regTree("/" + m_streamName + "/" + m_ntupleID, m_ntuplePtr).isFailure()) {
1479  ATH_MSG_ERROR( "Problem registering TileRec Tree");
1480  }
1481 
1482  TRIGGER_addBranch();
1483  CISPAR_addBranch();
1484  if (!m_laserObjectKey.empty()) {
1485  const TileLaserObject* laserObj =
1486  SG::makeHandle(m_laserObjectKey, ctx).get();
1487  m_las_version = laserObj->getVersion();
1488  LASER_addBranch();
1489  }
1490  DIGI_addBranch();
1491  TMDB_addBranch();
1492  }
1493 
1494  //DCS Ntuple creation
1495  if (m_checkDCS) {
1496  std::string ntupleDCS = "Tile_DCS";
1497  m_DCSntuplePtr = new TTree(ntupleDCS.c_str(), "TileCal-DCS data");
1498  if (m_thistSvc->regTree("/" + m_streamName + "/" + ntupleDCS, m_DCSntuplePtr).isFailure()) {
1499  ATH_MSG_ERROR( "Problem registering TileRec DCS Tree");
1500  }
1501  DCS_addBranch();
1502  }
1503 
1504  return StatusCode::SUCCESS;
1505 }

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

◆ LASER_addBranch()

void TileAANtuple::LASER_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variables Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 1709 of file TileAANtuple.cxx.

1709  {
1710 
1711  if (!m_laserObjectKey.empty()) {
1712 
1713  const char* gainnames[2] = {"LG","HG"};
1714  const char* channames[16] = {"Diode0","Diode1","Diode2","Diode3","Diode4","Diode5","Diode6","Diode7",
1715  "Diode8","Diode9","ExtCIS0","IntCIS","DiodePhocal","ExtCIS1","PMT1","PMT2"};
1716 
1717  m_ntuplePtr->Branch("LASER_BCID", &m_las_BCID, "LASER_BCID/I");
1718 
1719  m_ntuplePtr->Branch("LASER_FILTER", &m_las_Filt, "LASER_FILTER/I");
1720  m_ntuplePtr->Branch("LASER_REQAMP", &m_las_ReqAmp, "LASER_REQAMP/F");
1721  m_ntuplePtr->Branch("LASER_MEASAMP", &m_las_MeasAmp, "LASER_MEASAMP/F");
1722 
1723  if(m_las_version==2) {
1724 
1725  ATH_MSG_DEBUG("LASERII BRANCHING..");
1726 
1727  m_ntuplePtr->Branch(Form("LASER_QDCTIMEOUT"),&(m_qdctimeout),Form("LASER_QDCTIMEOUT/O"));
1728  m_ntuplePtr->Branch(Form("LASER_TDCTIMEOUT"),&(m_tdctimeout),Form("LASER_TDCTIMEOUT/O"));
1729  m_ntuplePtr->Branch(Form("LASER_DAQTYPE"),&(m_daqtype),Form("LASER_DAQTYPE/I"));
1730  for(int chan=0;chan<32;++chan){
1731  int ch=chan>>1;
1732  int gn=chan&1;
1733  m_ntuplePtr->Branch(Form("LASER_%s_%s_ADC",gainnames[gn],channames[ch]),&(m_arrays->m_chan[chan]),Form("LASER_%s_%s_ADC/I",gainnames[gn],channames[ch]));
1734  m_ntuplePtr->Branch(Form("LASER_%s_%s_Ped",gainnames[gn],channames[ch]),&(m_arrays->m_chan_Ped[chan]),Form("LASER_%s_%s_Ped/F",gainnames[gn],channames[ch]));
1735  m_ntuplePtr->Branch(Form("LASER_%s_%s_Led",gainnames[gn],channames[ch]),&(m_arrays->m_chan_Led[chan]),Form("LASER_%s_%s_Led/F",gainnames[gn],channames[ch]));
1736  m_ntuplePtr->Branch(Form("LASER_%s_%s_Ped1",gainnames[gn],channames[ch]),&(m_arrays->m_chan_Lin[chan]),Form("LASER_%s_%s_Ped1/F",gainnames[gn],channames[ch]));
1737  m_ntuplePtr->Branch(Form("LASER_%s_%s_Alpha",gainnames[gn],channames[ch]),&(m_arrays->m_chan_Alpha[chan]),Form("LASER_%s_%s_Alpha/F",gainnames[gn],channames[ch]));
1738  m_ntuplePtr->Branch(Form("LASER_%s_%s_Sigma_Ped",gainnames[gn],channames[ch]),&(m_arrays->m_chan_SPed[chan]),Form("LASER_%s_%s_Sigma_Ped/F",gainnames[gn],channames[ch]));
1739  m_ntuplePtr->Branch(Form("LASER_%s_%s_Sigma_Led",gainnames[gn],channames[ch]),&(m_arrays->m_chan_SLed[chan]),Form("LASER_%s_%s_Sigma_Led/F",gainnames[gn],channames[ch]));
1740  m_ntuplePtr->Branch(Form("LASER_%s_%s_Sigma_Ped1",gainnames[gn],channames[ch]),&(m_arrays->m_chan_SLin[chan]),Form("LASER_%s_%s_Sigma_Ped1/F",gainnames[gn],channames[ch]));
1741  m_ntuplePtr->Branch(Form("LASER_%s_%s_Sigma_Alpha",gainnames[gn],channames[ch]),&(m_arrays->m_chan_SAlpha[chan]),Form("LASER_%s_%s_Sigma_Alpha/F",gainnames[gn],channames[ch]));
1742  } // FOR
1743 
1744  } else {
1745 
1746  ATH_MSG_DEBUG("LASERI BRANCHING..");
1747 
1748  m_ntuplePtr->Branch("LASER_Diode_1_ADC", &(m_arrays->m_las_D_ADC[0][0]), "LASER_Diode_1_ADC/I");
1749  m_ntuplePtr->Branch("LASER_Diode_2_ADC", &(m_arrays->m_las_D_ADC[0][1]), "LASER_Diode_2_ADC/I");
1750  m_ntuplePtr->Branch("LASER_Diode_3_ADC", &(m_arrays->m_las_D_ADC[0][2]), "LASER_Diode_3_ADC/I");
1751  m_ntuplePtr->Branch("LASER_Diode_4_ADC", &(m_arrays->m_las_D_ADC[0][3]), "LASER_Diode_4_ADC/I");
1752 
1753  m_ntuplePtr->Branch("LASER_Diode_1_Ped", &(m_arrays->m_las_D_Ped[0][0]), "LASER_Diode_1_Ped/F");
1754  m_ntuplePtr->Branch("LASER_Diode_2_Ped", &(m_arrays->m_las_D_Ped[0][1]), "LASER_Diode_2_Ped/F");
1755  m_ntuplePtr->Branch("LASER_Diode_3_Ped", &(m_arrays->m_las_D_Ped[0][2]), "LASER_Diode_3_Ped/F");
1756  m_ntuplePtr->Branch("LASER_Diode_4_Ped", &(m_arrays->m_las_D_Ped[0][3]), "LASER_Diode_4_Ped/F");
1757 
1758  m_ntuplePtr->Branch("LASER_Diode_1_Ped_RMS", &(m_arrays->m_las_D_Ped_RMS[0][0]), "LASER_Diode_1_Ped_RMS/F");
1759  m_ntuplePtr->Branch("LASER_Diode_2_Ped_RMS", &(m_arrays->m_las_D_Ped_RMS[0][1]), "LASER_Diode_2_Ped_RMS/F");
1760  m_ntuplePtr->Branch("LASER_Diode_3_Ped_RMS", &(m_arrays->m_las_D_Ped_RMS[0][2]), "LASER_Diode_3_Ped_RMS/F");
1761  m_ntuplePtr->Branch("LASER_Diode_4_Ped_RMS", &(m_arrays->m_las_D_Ped_RMS[0][3]), "LASER_Diode_4_Ped_RMS/F");
1762 
1763  m_ntuplePtr->Branch("LASER_Diode_1_Alpha", &(m_arrays->m_las_D_Alpha[0][0]), "LASER_Diode_1_Alpha/F");
1764  m_ntuplePtr->Branch("LASER_Diode_2_Alpha", &(m_arrays->m_las_D_Alpha[0][1]), "LASER_Diode_2_Alpha/F");
1765  m_ntuplePtr->Branch("LASER_Diode_3_Alpha", &(m_arrays->m_las_D_Alpha[0][2]), "LASER_Diode_3_Alpha/F");
1766  m_ntuplePtr->Branch("LASER_Diode_4_Alpha", &(m_arrays->m_las_D_Alpha[0][3]), "LASER_Diode_4_Alpha/F");
1767 
1768  m_ntuplePtr->Branch("LASER_Diode_1_Alpha_RMS", &(m_arrays->m_las_D_Alpha_RMS[0][0]), "LASER_Diode_1_Alpha_RMS/F");
1769  m_ntuplePtr->Branch("LASER_Diode_2_Alpha_RMS", &(m_arrays->m_las_D_Alpha_RMS[0][1]), "LASER_Diode_2_Alpha_RMS/F");
1770  m_ntuplePtr->Branch("LASER_Diode_3_Alpha_RMS", &(m_arrays->m_las_D_Alpha_RMS[0][2]), "LASER_Diode_3_Alpha_RMS/F");
1771  m_ntuplePtr->Branch("LASER_Diode_4_Alpha_RMS", &(m_arrays->m_las_D_Alpha_RMS[0][3]), "LASER_Diode_4_Alpha_RMS/F");
1772 
1773  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed", &(m_arrays->m_las_D_AlphaPed[0][0]), "LASER_Diode_1_AlphaPed/F");
1774  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed", &(m_arrays->m_las_D_AlphaPed[0][1]), "LASER_Diode_2_AlphaPed/F");
1775  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed", &(m_arrays->m_las_D_AlphaPed[0][2]), "LASER_Diode_3_AlphaPed/F");
1776  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed", &(m_arrays->m_las_D_AlphaPed[0][3]), "LASER_Diode_4_AlphaPed/F");
1777 
1778  m_ntuplePtr->Branch("LASER_Diode_1_AlphaPed_RMS", &(m_arrays->m_las_D_AlphaPed_RMS[0][0]), "LASER_Diode_1_AlphaPed_RMS/F");
1779  m_ntuplePtr->Branch("LASER_Diode_2_AlphaPed_RMS", &(m_arrays->m_las_D_AlphaPed_RMS[0][1]), "LASER_Diode_2_AlphaPed_RMS/F");
1780  m_ntuplePtr->Branch("LASER_Diode_3_AlphaPed_RMS", &(m_arrays->m_las_D_AlphaPed_RMS[0][2]), "LASER_Diode_3_AlphaPed_RMS/F");
1781  m_ntuplePtr->Branch("LASER_Diode_4_AlphaPed_RMS", &(m_arrays->m_las_D_AlphaPed_RMS[0][3]), "LASER_Diode_4_AlphaPed_RMS/F");
1782 
1783  m_ntuplePtr->Branch("LASER_PMT_1_ADC", &(m_arrays->m_las_PMT_ADC[0][0]), "LASER_PMT_1_ADC/I");
1784  m_ntuplePtr->Branch("LASER_PMT_2_ADC", &(m_arrays->m_las_PMT_ADC[0][1]), "LASER_PMT_2_ADC/I");
1785 
1786  m_ntuplePtr->Branch("LASER_PMT_1_TDC", &(m_arrays->m_las_PMT_TDC[0][0]), "LASER_PMT_1_TDC/I");
1787  m_ntuplePtr->Branch("LASER_PMT_2_TDC", &(m_arrays->m_las_PMT_TDC[0][1]), "LASER_PMT_2_TDC/I");
1788 
1789  m_ntuplePtr->Branch("LASER_PMT_1_Ped", &(m_arrays->m_las_PMT_Ped[0][0]), "LASER_PMT_1_Ped/F");
1790  m_ntuplePtr->Branch("LASER_PMT_2_Ped", &(m_arrays->m_las_PMT_Ped[0][1]), "LASER_PMT_2_Ped/F");
1791 
1792  m_ntuplePtr->Branch("LASER_PMT_1_Ped_RMS", &(m_arrays->m_las_PMT_Ped_RMS[0][0]), "LASER_PMT_1_Ped_RMS/F");
1793  m_ntuplePtr->Branch("LASER_PMT_2_Ped_RMS", &(m_arrays->m_las_PMT_Ped_RMS[0][1]), "LASER_PMT_2_Ped_RMS/F");
1794 
1795  }
1796 
1797  m_ntuplePtr->Branch("LASER_HEAD_Temp", &m_las_Temperature, "LASER_HEAD_Temp/F");
1798  }
1799 }

◆ LASER_clearBranch()

void TileAANtuple::LASER_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variables

////////////////////////////////////////////////////////////////////////////

Definition at line 1808 of file TileAANtuple.cxx.

1808  {
1809 
1810  if (!m_laserObjectKey.empty()) {
1811 
1812  m_las_BCID = 0;
1813 
1814  m_las_Filt = 0;
1815  m_las_ReqAmp = 0.0;
1816  m_las_MeasAmp = 0.0;
1817  m_las_Temperature = 0.0;
1818 
1819  // LASERII
1820  // memset(m_arrays->m_chan, 0, sizeof(m_arrays->m_chan));
1821  // memset(m_arrays->m_chan_Ped, 0, sizeof(m_arrays->m_chan_Ped));
1822  // memset(m_arrays->m_chan_Led, 0, sizeof(m_arrays->m_chan_Led));
1823  // memset(m_arrays->m_chan_Lin, 0, sizeof(m_arrays->m_chan_Lin));
1824  // memset(m_arrays->m_chan_Alpha, 0, sizeof(m_arrays->m_chan_Alpha));
1825  // memset(m_arrays->m_chan_SPed, 0, sizeof(m_arrays->m_chan_SPed));
1826  // memset(m_arrays->m_chan_SLed, 0, sizeof(m_arrays->m_chan_SLed));
1827  // memset(m_arrays->m_chan_SLin, 0, sizeof(m_arrays->m_chan_SLin));
1828  // memset(m_arrays->m_chan_SAlpha, 0, sizeof(m_arrays->m_chan_SAlpha));
1829 
1830  // LASERI
1831  memset(m_arrays->m_las_D_ADC, 0, sizeof(m_arrays->m_las_D_ADC));
1832  memset(m_arrays->m_las_D_Ped, 0, sizeof(m_arrays->m_las_D_Ped));
1833  memset(m_arrays->m_las_D_Ped_RMS, 0, sizeof(m_arrays->m_las_D_Ped_RMS));
1834  memset(m_arrays->m_las_D_Alpha, 0, sizeof(m_arrays->m_las_D_Alpha));
1835  memset(m_arrays->m_las_D_Alpha_RMS, 0, sizeof(m_arrays->m_las_D_Alpha_RMS));
1836  memset(m_arrays->m_las_D_AlphaPed, 0, sizeof(m_arrays->m_las_D_AlphaPed));
1837  memset(m_arrays->m_las_D_AlphaPed_RMS, 0, sizeof(m_arrays->m_las_D_AlphaPed_RMS));
1838 
1839  memset(m_arrays->m_las_PMT_ADC, 0, sizeof(m_arrays->m_las_PMT_ADC));
1840  memset(m_arrays->m_las_PMT_TDC, 0, sizeof(m_arrays->m_las_PMT_TDC));
1841  memset(m_arrays->m_las_PMT_Ped, 0, sizeof(m_arrays->m_las_PMT_Ped));
1842  memset(m_arrays->m_las_PMT_Ped_RMS, 0, sizeof(m_arrays->m_las_PMT_Ped_RMS));
1843 
1844  }
1845 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ ntuple_clear()

StatusCode TileAANtuple::ntuple_clear ( )

Definition at line 1437 of file TileAANtuple.cxx.

1437  {
1438 
1439  TRIGGER_clearBranch();
1440  CISPAR_clearBranch();
1441  LASER_clearBranch();
1442  DIGI_clearBranch();
1443  TMDB_clearBranch();
1444 
1445  return StatusCode::SUCCESS;
1446 }

◆ ntuple_initialize()

StatusCode TileAANtuple::ntuple_initialize ( const EventContext &  ctx,
const TileDQstatus &  DQstatus 
)

Definition at line 275 of file TileAANtuple.cxx.

277 {
278  if (m_bsInput) {
279  ATH_CHECK( m_robSvc.retrieve() );
280  ATH_CHECK( m_decoder.retrieve() );
281  const TileHid2RESrcID* hid2re = m_decoder->getHid2re();
282  m_ROBID.push_back( hid2re->getRobFromFragID(DIGI_PAR_FRAG) );
283  m_ROBID.push_back( hid2re->getRobFromFragID(LASER_OBJ_FRAG) );
284  }
285 
286  uint32_t calib = DQstatus.calibMode();
287  bool calibMode = (calib == 1);
288  if ( calibMode != m_calibMode && calib!=0xFFFFFFFF ) {
289  ATH_MSG_INFO( "Calib mode from data is " << calibMode );
290  ATH_MSG_INFO( " Overwriting calib mode " );
291  m_calibMode = calibMode;
292  }
293 
294  if (m_finalUnit < TileRawChannelUnit::ADCcounts
295  || m_finalUnit > TileRawChannelUnit::OnlineMegaElectronVolts) {
296 
297  m_finalUnit = -1;
298  if ( !m_useDspUnits && m_calibrateEnergy ) {
299  m_useDspUnits = true;
300  ATH_MSG_INFO( "Final offline units are not set, will use DSP units" );
301  }
302  }
303 
304  if ( !m_calibrateEnergy && m_useDspUnits) {
305  ATH_MSG_INFO( "calibrateEnergy is disabled, don't want to use DSP units" );
306  m_useDspUnits = false;
307  }
308 
309  ATH_MSG_INFO( "calibMode " << m_calibMode );
310  ATH_MSG_INFO( "calibrateEnergy " << m_calibrateEnergy );
311  ATH_MSG_INFO( "offlineUnits " << m_finalUnit );
312  ATH_MSG_INFO( "useDspUnits " << m_useDspUnits );
313 
314  // set event number to 0 before first event
315  m_evtNr = 0;
316 
317  ATH_CHECK( m_thistSvc.retrieve() );
318 
319  if (m_compressSettings >= 0) {
320  ATH_CHECK( m_fileMgr.retrieve() );
321  }
322 
323  if(initNTuple(ctx).isFailure()) {
324  ATH_MSG_ERROR( " Error during ntuple initialization" );
325  }
326 
327  ATH_MSG_INFO( "ntuple initialization completed" );
328  return StatusCode::SUCCESS;
329 }

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

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ storeBeamElements()

StatusCode TileAANtuple::storeBeamElements ( const TileDQstatus &  DQstatus)
private

Definition at line 601 of file TileAANtuple.cxx.

601  {
602 
603  const uint32_t* cispar = DQstatus.cispar();
604 
605  uint32_t oldval = 0;
606  int last = 0;
607  for(int i = 0; i< N_CISPAR; ++i) {
608  m_cispar[i] = cispar[i];
609  if (msgLvl(MSG::VERBOSE)) {
610  if (oldval != cispar[i]) {
611  if (last < i-1) {
612  ATH_MSG_VERBOSE( "cispar[" << last << ".." << i-1 << "] = "
613  << oldval );
614  } else if (last == i-1) {
615  ATH_MSG_VERBOSE( "cispar[" << last << "] = " << oldval );
616  }
617  last = i;
618  oldval = cispar[i];
619  }
620  }
621  }
622 
623  if (msgLvl(MSG::VERBOSE)) {
624  if (last < N_CISPAR-1) {
625  ATH_MSG_VERBOSE( "cispar[" << last << ".." << N_CISPAR-1 << "] = "
626  << oldval );
627  } else {
628  ATH_MSG_VERBOSE( "cispar[" << last << "] = "<< oldval );
629  }
630  }
631 
632  m_trigType = cispar[12];
633 
634  return StatusCode::SUCCESS;
635 }

◆ storeDCS()

StatusCode TileAANtuple::storeDCS ( )
private

Definition at line 2252 of file TileAANtuple.cxx.

2252  {
2253 
2254  ATH_MSG_DEBUG( "Filling DCS ntuple:"
2255  <<" evtCnt=" << m_evtNr
2256  << " evt=" << m_evt
2257  << " lumi=" << m_lumiBlock << " " << m_dateTime );
2258 
2259  CLEAR(m_arrays->m_TEMP);
2260  CLEAR(m_arrays->m_HV);
2261  CLEAR(m_arrays->m_HVSET);
2262  CLEAR(m_arrays->m_DRSTATES);
2263  CLEAR(m_arrays->m_HVSTATUS);
2264  CLEAR(m_arrays->m_DRSTATUS);
2265  CLEAR(m_arrays->m_CHSTATUS);
2266 
2267  m_nBadDr = 0;
2268  m_nBadHV = 0;
2269  m_nBadDCS = 0;
2270  m_nBadDB = 0;
2271  m_nBadTotal = 0;
2272  for (int ROS = 1; ROS < 5; ++ROS) {
2273  int rosI = ROS - 1;
2274 
2275  for (int drawer = 0; drawer < 64; ++drawer) {
2276  m_arrays->m_DRSTATES[rosI][drawer] = m_tileDCS->getDrawerStates(ROS, drawer);
2277  m_arrays->m_DRSTATUS[rosI][drawer] = m_tileDCS->getDCSStatus(ROS, drawer);
2278  bool drbad = m_tileDCS->isStatusBad(ROS, drawer);
2279 
2280  if (drbad) {
2281  ++m_nBadDr;
2282  }
2283 
2284  if (msgLvl(MSG::VERBOSE) || m_arrays->m_DRSTATUS[rosI][drawer] != TileDCSState::OK_DRAWER) {
2285  ATH_MSG_VERBOSE( "Module=" << TileCalibUtils::getDrawerString(ROS, drawer)
2286  << " DRSTATES=" << m_arrays->m_DRSTATES[rosI][drawer]
2287  << " DRSTATUS=" << m_arrays->m_DRSTATUS[rosI][drawer]
2288  << " => " << ((drbad) ? "bad" : "good") );
2289  }
2290 
2291  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ROS,drawer);
2292  for (int channel=0; channel<48; ++channel){
2293  TileBchStatus chStat = m_tileBadChanTool->getChannelStatus(drawerIdx,channel);
2294  m_arrays->m_HV[rosI][drawer][channel] = m_tileDCS->getChannelHV(ROS, drawer, channel);
2295  m_arrays->m_HVSET[rosI][drawer][channel] = m_tileDCS->getChannelHVSet(ROS, drawer, channel);
2296  m_arrays->m_HVSTATUS[rosI][drawer][channel] = m_tileDCS->getDCSHVStatus(ROS, drawer, channel);
2297  m_arrays->m_CHSTATUS[rosI][drawer][channel] = m_tileDCS->getDCSStatus(ROS, drawer, channel)
2298  + 100 * m_tileBadChanTool->encodeStatus(chStat);
2299  bool chbad = m_tileDCS->isStatusBad(ROS, drawer, channel);
2300 
2301  if (chbad || chStat.isBad()) {
2302  ++m_nBadTotal;
2303  if (chbad) ++m_nBadDCS;
2304  if (chStat.isBad()) ++m_nBadDB;
2305  }
2306 
2307  if (m_tileDCS->isStatusHVBad(ROS, drawer, channel)) {
2308  ++m_nBadHV;
2309  }
2310 
2311  if (msgLvl(MSG::VERBOSE) || (chbad && !drbad)) {
2312  int pmt=abs(m_cabling->channel2hole(ROS,channel));
2313  ATH_MSG_VERBOSE( "Module=" << TileCalibUtils::getDrawerString(ROS, drawer)
2314  << " channel=" << channel << " pmt=" << pmt
2315  << " HV=" << m_arrays->m_HV[rosI][drawer][channel]
2316  << " HVSET=" << m_arrays->m_HVSET[rosI][drawer][channel]
2317  << " HVSTATUS=" << m_arrays->m_HVSTATUS[rosI][drawer][channel]
2318  << " CHSTATUS=" << m_arrays->m_CHSTATUS[rosI][drawer][channel]
2319  << " => " << ((chbad) ? "bad" : "good") );
2320  }
2321  }
2322 
2323  for (int ind=0; ind<7; ++ind){
2324  m_arrays->m_TEMP[rosI][drawer][ind] = m_tileDCS->getChannelHV(ROS, drawer, ind+48);
2325  ATH_MSG_VERBOSE( "Module=" << TileCalibUtils::getDrawerString(ROS, drawer)
2326  << " TEMP" << ind+1 << "=" << m_arrays->m_TEMP[rosI][drawer][ind] );
2327 
2328  }
2329  }
2330  }
2331 
2332  ATH_MSG_DEBUG( "BAD status in DCS: nBadDr=" << m_nBadDr
2333  << " nBadHV=" << m_nBadHV
2334  << " nBadDCS=" << m_nBadDCS
2335  << " nBadDB=" << m_nBadDB
2336  << " nBadTotal=" << m_nBadTotal );
2337 
2338  m_DCSntuplePtr->Fill();
2339 
2340 
2341  return StatusCode::SUCCESS;
2342 }

◆ storeDigits()

StatusCode TileAANtuple::storeDigits ( const EventContext &  ctx,
const SG::ReadHandleKey< TileDigitsContainer > &  containerKey,
short *  sample,
short  gain[N_ROS2][N_MODULES][N_CHANS],
bool  fillAll 
)
private

/ Fill Ntuple with info from TileDigits / Return true if the collection is empty

Store ROD header info from collection should be just one per ROD, i.e. either 64(in RUN1) or 128(starting from RUN2) different values

Full DMU header, stored for debugging

BCID in DMU header

bit_31==1 and bit_17==0

parity must be an odd number

memory parity error bit_25

single strobe error bit_24 (it is recovered)

double strobe error bit_23 (cannot be recovered)

Full DMU header, stored for debugging

BCID in DMU header

bit_31==1 and bit_17==0

parity must be an odd number

memory parity error bit_25

single strobe error bit_24 (it is recovered)

double strobe error bit_23 (cannot be recovered)

Definition at line 1044 of file TileAANtuple.cxx.

1049 {
1050  if (containerKey.empty()) // empty name, nothing to do
1051  return StatusCode::FAILURE;
1052 
1053  // Read Digits from TES
1054  const TileDigitsContainer* digitsCnt =
1055  SG::makeHandle (containerKey, ctx).get();
1056 
1057  bool emptyColl = true;
1058 
1059  // Get iterator for all TDColl in TDCont
1060  TileDigitsContainer::const_iterator itColl = (*digitsCnt).begin();
1061  TileDigitsContainer::const_iterator itCollEnd = (*digitsCnt).end();
1062 
1063  // Go through all TileDigitsCollections
1064  for(; itColl != itCollEnd; ++itColl) {
1065  int fragId = (*itColl)->identify();
1066  int drawer = fragId & 0x3F;
1067  int ROS = (fragId>>8);
1068  int rosI = ROS-1;
1069  int rosL = rosI;
1070  int rosH = rosI + N_ROS;
1071 
1072  if (msgLvl(MSG::VERBOSE)) {
1073  ATH_MSG_VERBOSE( "Event# " << m_evtNr
1074  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
1075  << " ROS " << ROS
1076  << " drawer " << drawer );
1077 
1078  if (fillAll) {
1079  ATH_MSG_VERBOSE( " Size=" << (*itColl)->getFragSize()
1080  << " BCID=" << (*itColl)->getFragBCID() << MSG::hex
1081  << " CRC=0x" << ((*itColl)->getFragCRC()&0xffff)
1082  << " DMUMask=0x" << ((*itColl)->getFragDMUMask()&0xffff) << MSG::dec );
1083 
1084  ATH_MSG_VERBOSE( " Lvl1ID=" << (*itColl)->getLvl1Id()
1085  << " Lvl1Type=" << (*itColl)->getLvl1Type()
1086  << " EvBCID=" << (*itColl)->getRODBCID()
1087  << " EvType=" << (*itColl)->getDetEvType() );
1088 
1089  ATH_MSG_VERBOSE(" Header=" << (*itColl)->getFragChipHeaderWords() );
1090  }
1091  }
1092 
1095  int rod = (rosL*N_MODULES + drawer);
1096  if (N_RODS<128) {
1097  rod >>= 2;
1098  } else if (N_RODS<256) {
1099  rod = (((rod>>2)<<1) | (rod&1));
1100  }
1101 
1102  m_l1ID[rod] = (*itColl)->getLvl1Id();
1103  m_l1Type[rod] = (*itColl)->getLvl1Type();
1104  m_evType[rod] = (*itColl)->getDetEvType();
1105  m_evBCID[rod] = (*itColl)->getRODBCID();
1106  if (m_trigType == 0) m_trigType = -m_l1Type[rod]; // make negative to distinguish from TileCal internal trig types
1107 
1108  TileDigitsCollection::const_iterator it = (*itColl)->begin();
1109  TileDigitsCollection::const_iterator itEnd = (*itColl)->end();
1110 
1111  // non empty collection
1112  if(it != itEnd) {
1113  emptyColl = false;
1114 
1115  if (fillAll) {
1116 
1117  // store evtnr, bcid,crc, size
1118  // Same for lo and hi, because they come from the same fragment
1119 
1120  m_arrays->m_rodBCID[rosL][drawer] = (*itColl)->getRODBCID();
1121  m_arrays->m_fragSize[rosL][drawer]=(*itColl)->getFragSize();
1122 
1123  m_arrays->m_slinkCRC[rosL][drawer][0] = ((*itColl)->getFragCRC()>>16) & 0xffff;
1124  m_arrays->m_dmuMask[rosL][drawer][0] = ((*itColl)->getFragDMUMask()>>16) & 0xffff;
1125  m_arrays->m_slinkCRC[rosL][drawer][1] = (*itColl)->getFragCRC() & 0xffff;
1126  m_arrays->m_dmuMask[rosL][drawer][1] = (*itColl)->getFragDMUMask() & 0xffff;
1127 
1128  uint32_t CRCmask = (*itColl)->getFragDMUMask(); //mask of FE+ROD DMU crc check (16bit+16bit) 0xffffffff == All ok
1129  uint32_t fe_crc = CRCmask & 0xFFFF;
1130  uint32_t rod_crc = CRCmask >> 16;
1131 
1132  const std::vector<uint32_t> & headerVec = (*itColl)->getFragChipHeaderWords();
1133  unsigned int headsize = std::min(16U, static_cast<unsigned int>(headerVec.size()));
1134 
1135  for (unsigned int ih = 0; ih < headsize; ++ih) {
1136 
1137  m_arrays->m_DMUheader[rosL][drawer][ih] = headerVec[ih];
1138  m_arrays->m_DMUbcid[rosL][drawer][ih] = (headerVec[ih] & 0xFFF);
1139  m_arrays->m_DMUformatErr[rosL][drawer][ih] = CheckDMUFormat(headerVec[ih]);
1140  m_arrays->m_DMUparityErr[rosL][drawer][ih] = CheckDMUParity(headerVec[ih]);
1141  m_arrays->m_DMUmemoryErr[rosL][drawer][ih] = (headerVec[ih] >> 25 & 0x1);
1142  m_arrays->m_DMUSstrobeErr[rosL][drawer][ih] = (headerVec[ih] >> 24 & 0x1);
1143  m_arrays->m_DMUDstrobeErr[rosL][drawer][ih] = (headerVec[ih] >> 23 & 0x1);
1144 
1145  m_arrays->m_feCRC[rosL][drawer][ih] = (fe_crc >> ih & 0x1);
1146  m_arrays->m_rodCRC[rosL][drawer][ih] = (rod_crc >> ih & 0x1);
1147  }
1148 
1149  if (m_calibMode) {
1150  const std::vector<uint32_t> & headerVecHi = (*itColl)->getFragChipHeaderWordsHigh();
1151  unsigned int headsizehi = std::min(16U, static_cast<unsigned int>(headerVecHi.size()));
1152 
1153  for (unsigned int ih = 0; ih < headsizehi; ++ih) {
1154 
1155  m_arrays->m_DMUheader[rosH][drawer][ih] = headerVecHi[ih];
1156  m_arrays->m_DMUbcid[rosH][drawer][ih] = (headerVecHi[ih] & 0xFFF);
1157  m_arrays->m_DMUformatErr[rosH][drawer][ih] = CheckDMUFormat(headerVecHi[ih]);
1158  m_arrays->m_DMUparityErr[rosH][drawer][ih] = CheckDMUParity(headerVecHi[ih]);
1159  m_arrays->m_DMUmemoryErr[rosH][drawer][ih] = (headerVecHi[ih] >> 25 & 0x1);
1160  m_arrays->m_DMUSstrobeErr[rosH][drawer][ih] = (headerVecHi[ih] >> 24 & 0x1);
1161  m_arrays->m_DMUDstrobeErr[rosH][drawer][ih] = (headerVecHi[ih] >> 23 & 0x1);
1162 
1163  m_arrays->m_feCRC[rosH][drawer][ih] = -1 ; //Variables must be filled anyway, empty variables are not allowed
1164  m_arrays->m_rodCRC[rosH][drawer][ih] = -1; //Variables must be filled anyway, empty variables are not allowed
1165  }
1166  }
1167  }
1168 
1169 
1170  int cmpCounter = 0;
1171  // go through all TileDigits in collection
1172  for (; it != itEnd; ++it) {
1173  const TileDigits* digit = (*it);
1174 
1175  HWIdentifier hwid = digit->adc_HWID();
1176 
1177  // determine channel
1178  int channel = m_tileHWID->channel(hwid);
1179  // convert channel number to PMT number if needed
1180  if (m_pmtOrder) channel = digiChannel2PMT(ROS,channel);
1181 
1182  // determine gain and set ros index accordingly
1183  int gain = m_tileHWID->adc(hwid);
1184  if (m_calibMode) {
1185  if (m_compareMode) {
1186  ++cmpCounter;
1187  if (cmpCounter > 48) rosI = rosH;
1188  else rosI = rosL;
1189  } else {
1190  if (gain == 1) rosI = rosH;
1191  else rosI = rosL;
1192  }
1193  }
1194 
1195  a_gain[rosI][drawer][channel] = gain;
1196 
1197  // get digits
1198  const std::vector<float> & sampleVec = digit->samples();
1199  int siz = sampleVec.size();
1200  if (msgLvl(MSG::VERBOSE)) {
1201  int index,pmt;
1202  digit->cell_ID_index(index,pmt);
1203  msg(MSG::VERBOSE) << "TD ch " << channel
1204  << " gain "<< gain
1205  << " type " << std::min(index,0) << " {";
1206  for(int i=0;i<siz;i++) {
1207  msg(MSG::VERBOSE) <<(int)sampleVec[i] << " ";
1208  }
1209  }
1210  // changed N_SAMPLES to number of samples from tile configurator
1211  if (siz > m_nSamples) {
1212  siz = m_nSamples;
1213  if (msgLvl(MSG::VERBOSE))
1214  ATH_MSG_VERBOSE( "} ONLY " << siz << " digits saved to ntuple" );
1215  } else {
1216  if (msgLvl(MSG::VERBOSE))
1217  ATH_MSG_VERBOSE( "}" );
1218  }
1219  for (int n = 0; n < siz; ++n) {
1220  a_sample[sample_ind(rosI,drawer,channel,n)] = (short) sampleVec[n];
1221  }
1222  }
1223  }
1224  }
1225 
1226  if (emptyColl) return StatusCode::FAILURE;
1227  else return StatusCode::SUCCESS;
1228 }

◆ storeLaser()

StatusCode TileAANtuple::storeLaser ( const EventContext &  ctx)
private

Definition at line 492 of file TileAANtuple.cxx.

492  {
493 
494  ATH_MSG_DEBUG("TileAANtuple::storeLaser()");
495  const char* gainnames[2] = {"LG","HG"};
496 
497  const TileLaserObject* laserObj = SG::makeHandle(m_laserObjectKey, ctx).get();
498 
499  m_las_BCID = laserObj->getBCID();
500 
501  m_las_Filt = laserObj->getFiltNumber();
502  m_las_ReqAmp = laserObj->getDiodeCurrOrd();
503  m_las_MeasAmp = laserObj->getDiodeCurrMeas();
504  m_las_Temperature = laserObj->getPumpDiodeTemp();
505  ATH_MSG_VERBOSE( "Laser BCID " << m_las_BCID
506  << " Filt " << m_las_Filt
507  << " ReqAmp " << m_las_ReqAmp
508  << " MeasAmp " << m_las_MeasAmp
509  << " Temp " << m_las_Temperature );
510 
511  ATH_MSG_DEBUG("LASER"<<(laserObj->isLASERII()?"II":"I")<<" VERSION IS " << laserObj->getVersion());
512 
513  if(laserObj->isLASERII()){
514  m_qdctimeout = laserObj->getQDCTimeout();
515  m_tdctimeout = laserObj->getTDCTimeout();
516  m_daqtype = laserObj->getDaqType();
517  if (msgLvl(MSG::DEBUG)) {
518  msg(MSG::DEBUG) << "DAQ Type " << m_daqtype << endmsg;
519  msg(MSG::DEBUG) << "QDC TimeOut " << m_qdctimeout << endmsg;
520  msg(MSG::DEBUG) << "TDC TimeOut " << m_tdctimeout << endmsg;
521  }
522 
523  // RETRIEVE SIGNAL IN ADC COUNTS
524  for(int chan=0;chan<28;++chan){
525  int ch=chan>>1;
526  int gn=chan&1;
527  // MONITORING DIODES
528  m_arrays->m_chan[chan] = laserObj->getDiodeADC(ch,gn);
529  ATH_MSG_DEBUG("LASERII CHANNEL " << ch << " ("<<gainnames[gn]<<") " << m_arrays->m_chan[chan]);
530  } // FOR
531 
532  for(int chan=28;chan<32;++chan){
533  int ch=(chan-28)>>1;
534  int gn=chan&1;
535  // MONITORING PMTS
536  m_arrays->m_chan[chan] = laserObj->getPMADC(ch,gn);
537  ATH_MSG_DEBUG("LASERII PMT " << ch << " ("<<gainnames[gn]<<") " << m_arrays->m_chan[chan]);
538  } // FOR
539 
540  // RETRIEVE PEDESTALS IF NOT ALREADY SET
541  for(int chan=0;chan<32;++chan){
542  int ch=chan>>1;
543  int gn=chan&1;
544  if(laserObj->isSet(ch, gn, 0) && laserObj->getMean (ch,gn,0)>0) m_arrays->m_chan_Ped[chan] = laserObj->getMean (ch,gn,0);
545  if(laserObj->isSet(ch, gn, 2) && laserObj->getMean (ch,gn,2)>0) m_arrays->m_chan_Led[chan] = laserObj->getMean (ch,gn,2);
546  if(laserObj->isSet(ch, gn, 3) && laserObj->getMean (ch,gn,3)>0) m_arrays->m_chan_Alpha[chan] = laserObj->getMean (ch,gn,3);
547  if(laserObj->isSet(ch, gn, 1) && laserObj->getMean (ch,gn,1)>0) m_arrays->m_chan_Lin[chan] = laserObj->getMean (ch,gn,1);
548  if(laserObj->isSet(ch, gn, 0) && laserObj->getSigma(ch,gn,0)>0) m_arrays->m_chan_SPed[chan] = laserObj->getSigma(ch,gn,0);
549  if(laserObj->isSet(ch, gn, 2) && laserObj->getSigma(ch,gn,2)>0) m_arrays->m_chan_SLed[chan] = laserObj->getSigma(ch,gn,2);
550  if(laserObj->isSet(ch, gn, 3) && laserObj->getSigma(ch,gn,3)>0) m_arrays->m_chan_SAlpha[chan] = laserObj->getSigma(ch,gn,3);
551  if(laserObj->isSet(ch, gn, 1) && laserObj->getSigma(ch,gn,1)>0) m_arrays->m_chan_SLin[chan] = laserObj->getSigma(ch,gn,1);
552 
553  // DEBUG OUTPUT
554  if (msgLvl(MSG::DEBUG)) {
555  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " SIG= " << m_arrays->m_chan[chan] << endmsg;
556  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " PED= " << m_arrays->m_chan_Ped[chan] << "+/-" << m_arrays->m_chan_SPed[chan] << " ( " << laserObj->isSet(ch, gn, 0) << " ) " << endmsg;
557  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " PED= " << m_arrays->m_chan_Lin[chan] << "+/-" << m_arrays->m_chan_SLin[chan] << " ( " << laserObj->isSet(ch, gn, 1) << " ) " << endmsg;
558  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " LED= " << m_arrays->m_chan_Led[chan] << "+/-" << m_arrays->m_chan_SLed[chan] << " ( " << laserObj->isSet(ch, gn, 2) << " ) " << endmsg;
559  msg(MSG::DEBUG) << gainnames[gn] << " CHAN " << ch << " ALP= " << m_arrays->m_chan_Alpha[chan] << "+/-" << m_arrays->m_chan_SAlpha[chan] << " ( " << laserObj->isSet(ch, gn, 3) << " ) " << endmsg;
560  } // IF
561  } // FOR
562  } // IF
563  else{
564  for (unsigned int gn=0; gn<TileLaserObject::nbGains; ++gn) {
565  for (unsigned int i=0; i<TileLaserObject::nbPmts; ++i) {
566  m_arrays->m_las_PMT_ADC[gn][i] = laserObj->getPMADC(i,gn);
567  m_arrays->m_las_PMT_TDC[gn][i] = laserObj->getTDC(i,gn);
568  m_arrays->m_las_PMT_Ped[gn][i] = laserObj->getPMPedestal(i,gn);
569  m_arrays->m_las_PMT_Ped_RMS[gn][i] = laserObj->getPMSigmaPedestal(i,gn);
570  ATH_MSG_VERBOSE( "LasPMT" << i << " g " << gn
571  << " adc " << m_arrays->m_las_PMT_ADC[gn][i]
572  << " ped " << m_arrays->m_las_PMT_Ped[gn][i]
573  << " rms " << m_arrays->m_las_PMT_Ped_RMS[gn][i]
574  << " tdc " << m_arrays->m_las_PMT_TDC[gn][i] );
575  } // FOR
576 
577  for (unsigned int i=0; i<14; ++i) {
578  m_arrays->m_las_D_ADC[gn][i] = laserObj->getDiodeADC(i,gn);
579  m_arrays->m_las_D_Ped[gn][i] = laserObj->getDiodePedestal(i,gn);
580  m_arrays->m_las_D_Ped_RMS[gn][i] = laserObj->getDiodeSigmaPedestal(i,gn);
581  m_arrays->m_las_D_Alpha[gn][i] = laserObj->getAlpha(i,gn);
582  m_arrays->m_las_D_Alpha_RMS[gn][i] = laserObj->getSigmaAlpha(i,gn);
583  m_arrays->m_las_D_AlphaPed[gn][i] = laserObj->getPedestalAlpha(i,gn);
584  m_arrays->m_las_D_AlphaPed_RMS[gn][i] = laserObj->getSigmaPedAlpha(i,gn);
585 
586  ATH_MSG_VERBOSE( "LasD" << i << " g " << gn
587  << " adc " << m_arrays->m_las_D_ADC[gn][i]
588  << " ped " << m_arrays->m_las_D_Ped[gn][i]
589  << " rms " << m_arrays->m_las_D_Ped_RMS[gn][i]
590  << " alp " << m_arrays->m_las_D_Alpha[gn][i]
591  << " rms " << m_arrays->m_las_D_Alpha_RMS[gn][i]
592  << " ape " << m_arrays->m_las_D_AlphaPed[gn][i]
593  << " rms " << m_arrays->m_las_D_AlphaPed_RMS[gn][i] );
594  } // FOR
595  } // FOR
596  } // ELSE
597 
598  return StatusCode::SUCCESS;
599 }

◆ storeMFRawChannels()

StatusCode TileAANtuple::storeMFRawChannels ( const EventContext &  ctx,
const SG::ReadHandleKey< TileRawChannelContainer > &  containerKey,
float *  ene,
float *  time,
float  chi2[N_ROS2][N_MODULES][N_CHANS],
float  ped[N_ROS2][N_MODULES][N_CHANS],
bool  fillAll 
)
private

final calibration

Definition at line 840 of file TileAANtuple.cxx.

847 {
848  if (containerKey.empty()) {// empty name, nothing to do
849  return StatusCode::FAILURE;
850  }
851 
852  // get named container
853  const TileRawChannelContainer* rcCnt = \
854  SG::makeHandle (containerKey, ctx).get();
855 
856  TileRawChannelUnit::UNIT rChUnit = rcCnt->get_unit();
857  ATH_MSG_VERBOSE( "RawChannel unit is " << rChUnit );
858 
859  bool dspCont = ( rChUnit >= TileRawChannelUnit::OnlineADCcounts );
860  if (dspCont) { // this is container with DSP results
861  m_dspUnit = rChUnit;
862  m_dspFlags = rcCnt->get_bsflags() >> 16;
863  ATH_MSG_VERBOSE( "DSP flag is 0x" << MSG::hex << m_dspFlags << MSG::dec
864  << " DSP unit is " << m_dspUnit);
865 
866  } else if ((m_useDspUnits || m_finalUnit >= TileRawChannelUnit::OnlineADCcounts)
867  && rChUnit != TileRawChannelUnit::ADCcounts) {
868  ATH_MSG_ERROR( "RawChannel units are not ADC counts, can't apply DSP-like calibration" );
869  return StatusCode::FAILURE;
870  }
871 
872  if (m_calibrateEnergy) {
873  if (m_useDspUnits) { // calibrate a-la online
874  m_rchUnit = m_dspUnit;
875  } else { // convert to final units
876  m_rchUnit = (TileRawChannelUnit::UNIT)m_finalUnit;
877  }
878  } else {
879  m_rchUnit = rChUnit;
880  }
881  ATH_MSG_VERBOSE( "Final RawChannel unit is " << m_rchUnit );
882 
883  std::vector<float> sumE(3);
884  float E[48];
885  int gain[48];
886  if (m_compareMode && dspCont) memset(m_bad, 0, sizeof(m_bad));
887 
888  // Get iterator for all TRCColl in TRCCont
889  TileRawChannelContainer::const_iterator itColl = (*rcCnt).begin();
890  TileRawChannelContainer::const_iterator itCollEnd = (*rcCnt).end();
891 
892  TileRawChannelCollection::const_iterator it, itEnd;
893 
894  // Go through all TileRawChannelCollections
895  for (; itColl != itCollEnd; ++itColl) {
896  int fragId = (*itColl)->identify();
897  int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
898  int drawer = fragId & 0x3F;
899  int ROS = (fragId >> 8);
900  int rosI = ROS - 1;
901  int rosL = rosI;
902  int rosH = rosI + N_ROS;
903 
904  ATH_MSG_VERBOSE( "TRC ("<< containerKey.key()
905  <<") Event# "<< m_evtNr
906  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
907  << " ROS " << ROS
908  << " drawer " << drawer );
909 
910  // go through all TileRawChannels in collection
911  it = (*itColl)->begin();
912  itEnd = (*itColl)->end();
913 
914  int cmpCounter = 0;
915  if (m_compareMode) {
916  memset(E, 0, sizeof(E));
917  memset(gain, 0, sizeof(gain));
918  }
919  for(; it != itEnd; ++it) {
920  const TileRawChannel* rch = (*it);
921 
922  HWIdentifier hwid=rch->adc_HWID();
923 
924  // determine channel
925  int channel = m_tileHWID->channel(hwid);
926  // convert channel number to PMT number if needed
927  if (m_pmtOrder) channel = digiChannel2PMT(ROS,channel);
928 
929  // determine gain and set ros index accordingly
930  int adc = m_tileHWID->adc(hwid);
931  if (m_calibMode) {
932  if (m_compareMode) {
933  ++cmpCounter;
934  if(cmpCounter>48) rosI = rosH;
935  else rosI = rosL;
936  } else {
937  if(adc == 1) rosI = rosH;
938  else rosI = rosL;
939  }
940  }
941 
943  float energy = 0.;
944  for (int i = 0; i < 7; ++i) {
945  energy = rch->amplitude(i);
946  if (m_rchUnit != rChUnit) {
947  if (m_rchUnit < TileRawChannelUnit::OnlineOffset)
948  energy = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, energy, rChUnit, m_rchUnit);
949  else
950  energy = m_tileToolEmscale->channelCalibOnl(drawerIdx, channel, adc, energy, m_rchUnit);
951  }
952 
953  ene[sample_ind(rosI,drawer,channel,i)] = energy;
954  time[sample_ind(rosI,drawer,channel,i)] = rch->time(i);
955  }
956  chi2[rosI][drawer][channel] = rch->quality();
957  ped[rosI][drawer][channel] = rch->pedestal();
958 
959  if (m_arrays->m_gain[rosI][drawer][channel] < 0)
960  m_arrays->m_gain[rosI][drawer][channel] = adc;
961 
962  if (m_compareMode) { // filling array for SumEt calculations
963  E[channel] = ene[sample_ind(rosI,drawer,channel,0)];
964  gain[channel] = adc;
965  if (dspCont) { // use bad flag from DSP container only
966  m_bad[rosL][drawer][channel] = (rch->quality() > 15.99);
967  //} else {
968  //m_bad[rosL][drawer][channel] = m_tileBadChanTool->getAdcStatus(drawerIdx, channel, adc).isBad();
969  }
970  }
971 
972  if (msgLvl(MSG::VERBOSE)) {
973  int index,pmt;
974  rch->cell_ID_index(index,pmt);
975  ATH_MSG_VERBOSE( "TRC ch " << channel
976  << " gain " << adc
977  << " type " << std::min(index,0)
978  << " ene=" << ene[sample_ind(rosI,drawer,channel,0)]
979  << " time=" << rch->time()
980  << " chi2=" << rch->quality()
981  << " ped=" << rch->pedestal() );
982  }
983  }
984 
985  if (fillAll) {
986 
987  m_arrays->m_ROD_GlobalCRC[rosL][drawer] = (*itColl)->getFragGlobalCRC() & 1;
988  m_arrays->m_ROD_BCID[rosL][drawer] = (*itColl)->getFragDSPBCID();
989  m_arrays->m_ROD_DMUMask[rosL][drawer][0] = (*itColl)->getFragRODChipMask();
990  m_arrays->m_ROD_DMUMask[rosL][drawer][1] = (*itColl)->getFragFEChipMask();
991 
992  for(unsigned int dmu=0;dmu<N_DMUS;dmu++) {
993 
994  m_arrays->m_ROD_DMUBCIDErr[rosL][drawer][dmu] = ((*itColl)->getFragBCID() >> dmu) & 1;
995  m_arrays->m_ROD_DMUmemoryErr[rosL][drawer][dmu] = ((*itColl)->getFragMemoryPar() >> dmu) & 1;
996  m_arrays->m_ROD_DMUSstrobeErr[rosL][drawer][dmu] = ((*itColl)->getFragSstrobe() >> dmu) & 1;
997  m_arrays->m_ROD_DMUDstrobeErr[rosL][drawer][dmu] = ((*itColl)->getFragDstrobe() >> dmu) & 1;
998  m_arrays->m_ROD_DMUHeadformatErr[rosL][drawer][dmu] = ((*itColl)->getFragHeaderBit() >> dmu) & 1;
999  m_arrays->m_ROD_DMUHeadparityErr[rosL][drawer][dmu] = ((*itColl)->getFragHeaderPar() >> dmu) & 1;
1000  m_arrays->m_ROD_DMUDataformatErr[rosL][drawer][dmu] = ((*itColl)->getFragSampleBit() >> dmu) & 1;
1001  m_arrays->m_ROD_DMUDataparityErr[rosL][drawer][dmu] = ((*itColl)->getFragSamplePar() >> dmu) & 1;
1002  m_arrays->m_ROD_DMUfeCRC[rosL][drawer][dmu] = ((*itColl)->getFragFEChipMask() >> dmu) & 1;
1003  m_arrays->m_ROD_DMUrodCRC[rosL][drawer][dmu] = ((*itColl)->getFragRODChipMask() >> dmu) & 1;
1004  }
1005  }
1006 
1007  if (m_compareMode) {
1008  m_l2Builder->SumE(ROS, drawer, m_rchUnit, E, gain, m_bad[rosL][drawer], sumE);
1009  if (dspCont) {
1010  m_sumEt_xx[m_l2Builder->idToIndex(fragId)] = sumE[0];
1011  m_sumEz_xx[m_l2Builder->idToIndex(fragId)] = sumE[1];
1012  m_sumE_xx[m_l2Builder->idToIndex(fragId)] = sumE[2];
1013  }
1014  else {
1015  m_sumEt_zz[m_l2Builder->idToIndex(fragId)] = sumE[0];
1016  m_sumEz_zz[m_l2Builder->idToIndex(fragId)] = sumE[1];
1017  m_sumE_zz[m_l2Builder->idToIndex(fragId)] = sumE[2];
1018  }
1019  }
1020  }
1021 
1022  if (m_compareMode && dspCont) {
1023 
1024  const TileL2Container* l2Cnt = SG::makeHandle(m_l2CntKey, ctx).get();
1025 
1026  TileL2Container::const_iterator it = l2Cnt->begin();
1027  TileL2Container::const_iterator end= l2Cnt->end();
1028  int i=0;
1029  for(; it != end; ++it) {
1030  m_sumEt_yy[i++] = (*it)->sumEt();
1031  m_sumEz_yy[i++] = (*it)->sumEz();
1032  m_sumE_yy[i++] = (*it)->sumE();
1033  }
1034  }
1035 
1036  return StatusCode::SUCCESS;
1037 }

◆ storeRawChannels()

StatusCode TileAANtuple::storeRawChannels ( const EventContext &  ctx,
const SG::ReadHandleKey< TileRawChannelContainer > &  containerKey,
float  ene[N_ROS2][N_MODULES][N_CHANS],
float  time[N_ROS2][N_MODULES][N_CHANS],
float  chi2[N_ROS2][N_MODULES][N_CHANS],
float  ped[N_ROS2][N_MODULES][N_CHANS],
bool  fillAll 
)
private

/ Fill ntuple with data from TRC.

final calibration

Definition at line 642 of file TileAANtuple.cxx.

649 {
650  if (containerKey.empty()) {// empty name, nothing to do
651  return StatusCode::FAILURE;
652  }
653 
654  // get named container
655  const TileRawChannelContainer* rcCnt =
656  SG::makeHandle (containerKey, ctx).get();
657  ATH_MSG_VERBOSE( "Container ID " << containerKey.key() );
658 
659  TileRawChannelUnit::UNIT rChUnit = rcCnt->get_unit();
660  ATH_MSG_VERBOSE( "RawChannel unit is " << rChUnit );
661 
662  bool dspCont = ( rChUnit >= TileRawChannelUnit::OnlineADCcounts );
663  if (dspCont) { // this is container with DSP results
664  m_dspUnit = rChUnit;
665  m_dspFlags = rcCnt->get_bsflags() >> 16;
666  ATH_MSG_VERBOSE( "DSP flag is 0x" << MSG::hex << m_dspFlags << MSG::dec
667  << " DSP unit is " << m_dspUnit);
668 
669  } else if ((m_useDspUnits || m_finalUnit >= TileRawChannelUnit::OnlineADCcounts)
670  && rChUnit != TileRawChannelUnit::ADCcounts) {
671  ATH_MSG_ERROR( "RawChannel units are not ADC counts, can't apply DSP-like calibration" );
672  return StatusCode::FAILURE;
673  }
674 
675  if (m_calibrateEnergy) {
676  if (m_useDspUnits) { // calibrate a-la online
677  m_rchUnit = m_dspUnit;
678  } else { // convert to final units
679  m_rchUnit = (TileRawChannelUnit::UNIT)m_finalUnit;
680  }
681  } else {
682  m_rchUnit = rChUnit;
683  }
684  ATH_MSG_VERBOSE( "Final RawChannel unit is " << m_rchUnit );
685 
686  std::vector<float> sumE(3);
687  float E[48];
688  int gain[48];
689  if (m_compareMode && dspCont) memset(m_bad,0,sizeof(m_bad));
690 
691  // Get iterator for all TRCColl in TRCCont
692  TileRawChannelContainer::const_iterator itColl = (*rcCnt).begin();
693  TileRawChannelContainer::const_iterator itCollEnd = (*rcCnt).end();
694 
695  TileRawChannelCollection::const_iterator it, itEnd;
696 
697  // Go through all TileRawChannelCollections
698  for(; itColl != itCollEnd; ++itColl) {
699  int fragId = (*itColl)->identify();
700  int drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
701  int drawer = fragId & 0x3F;
702  int ROS = (fragId>>8);
703  int rosI = ROS-1;
704  int rosL = rosI;
705  int rosH = rosI + N_ROS;
706 
707  ATH_MSG_VERBOSE( "TRC ("<< containerKey.key()
708  <<") Event# "<< m_evtNr
709  << " Frag id 0x" << MSG::hex << fragId << MSG::dec
710  << " ROS " << ROS
711  << " drawer " << drawer );
712 
713  // go through all TileRawChannels in collection
714  it = (*itColl)->begin();
715  itEnd = (*itColl)->end();
716 
717  int cmpCounter = 0;
718  if (m_compareMode) {
719  memset(E, 0, sizeof(E));
720  memset(gain, 0, sizeof(gain));
721  }
722 
723  for(; it != itEnd; ++it) {
724  const TileRawChannel* rch = (*it);
725 
726  HWIdentifier hwid = rch->adc_HWID();
727 
728  // determine channel
729  int channel = m_tileHWID->channel(hwid);
730  // convert channel number to PMT number if needed
731  if (m_pmtOrder) channel = digiChannel2PMT(ROS,channel);
732 
733  // determine gain and set ros index accordingly
734  int adc = m_tileHWID->adc(hwid);
735  if (m_calibMode) {
736  if (m_compareMode) {
737  ++cmpCounter;
738  if(cmpCounter>48) rosI = rosH;
739  else rosI = rosL;
740  } else {
741  if(adc == 1) rosI = rosH;
742  else rosI = rosL;
743  }
744  }
745 
747  float energy = rch->amplitude();
748  if (m_rchUnit != rChUnit) {
749  if (m_rchUnit < TileRawChannelUnit::OnlineOffset)
750  energy = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, energy, rChUnit, m_rchUnit);
751  else
752  energy = m_tileToolEmscale->channelCalibOnl(drawerIdx, channel, adc, energy, m_rchUnit);
753  }
754 
755  ene[rosI][drawer][channel] = energy;
756  time[rosI][drawer][channel] = rch->time();
757  chi2[rosI][drawer][channel] = rch->quality();
758  ped[rosI][drawer][channel] = rch->pedestal();
759  if (m_arrays->m_gain[rosI][drawer][channel] < 0)
760  m_arrays->m_gain[rosI][drawer][channel] = adc;
761 
762  if (m_compareMode) { // filling array for SumEt calculations
763  E[channel] = energy;
764  gain[channel] = adc;
765  if (dspCont) { // use bad flag from DSP container only
766  m_bad[rosL][drawer][channel] = (rch->quality()>15.99);
767  //} else {
768  //m_bad[rosL][drawer][channel] = m_tileBadChanTool->getAdcStatus(drawerIdx, channel, adc).isBad();
769  }
770  }
771 
772  if (msgLvl(MSG::VERBOSE)) {
773  int index,pmt;
774  rch->cell_ID_index(index,pmt);
775  ATH_MSG_VERBOSE( "TRC ch " << channel
776  << " gain " << adc
777  << " type " << std::min(index,0)
778  << " ene=" << energy
779  << " time=" << rch->time()
780  << " chi2=" << rch->quality()
781  << " ped=" << rch->pedestal() );
782  }
783  }
784 
785  if (fillAll) {
786 
787  m_arrays->m_ROD_GlobalCRC[rosL][drawer] = (*itColl)->getFragGlobalCRC() & 1;
788  m_arrays->m_ROD_BCID[rosL][drawer] = (*itColl)->getFragDSPBCID();
789  m_arrays->m_ROD_DMUMask[rosL][drawer][0] = (*itColl)->getFragRODChipMask();
790  m_arrays->m_ROD_DMUMask[rosL][drawer][1] = (*itColl)->getFragFEChipMask();
791 
792  for(unsigned int dmu=0;dmu<N_DMUS;dmu++) {
793 
794  m_arrays->m_ROD_DMUBCIDErr[rosL][drawer][dmu] = ((*itColl)->getFragBCID() >> dmu) & 1;
795  m_arrays->m_ROD_DMUmemoryErr[rosL][drawer][dmu] = ((*itColl)->getFragMemoryPar() >> dmu) & 1;
796  m_arrays->m_ROD_DMUSstrobeErr[rosL][drawer][dmu] = ((*itColl)->getFragSstrobe() >> dmu) & 1;
797  m_arrays->m_ROD_DMUDstrobeErr[rosL][drawer][dmu] = ((*itColl)->getFragDstrobe() >> dmu) & 1;
798  m_arrays->m_ROD_DMUHeadformatErr[rosL][drawer][dmu] = ((*itColl)->getFragHeaderBit() >> dmu) & 1;
799  m_arrays->m_ROD_DMUHeadparityErr[rosL][drawer][dmu] = ((*itColl)->getFragHeaderPar() >> dmu) & 1;
800  m_arrays->m_ROD_DMUDataformatErr[rosL][drawer][dmu] = ((*itColl)->getFragSampleBit() >> dmu) & 1;
801  m_arrays->m_ROD_DMUDataparityErr[rosL][drawer][dmu] = ((*itColl)->getFragSamplePar() >> dmu) & 1;
802  m_arrays->m_ROD_DMUfeCRC[rosL][drawer][dmu] = ((*itColl)->getFragFEChipMask() >> dmu) & 1;
803  m_arrays->m_ROD_DMUrodCRC[rosL][drawer][dmu] = ((*itColl)->getFragRODChipMask() >> dmu) & 1;
804  }
805  }
806 
807  if (m_compareMode) {
808  m_l2Builder->SumE(ROS,drawer,m_rchUnit,E,gain,m_bad[rosL][drawer],sumE);
809  if (dspCont) {
810  m_sumEt_xx[m_l2Builder->idToIndex(fragId)] = sumE[0];
811  m_sumEz_xx[m_l2Builder->idToIndex(fragId)] = sumE[1];
812  m_sumE_xx[m_l2Builder->idToIndex(fragId)] = sumE[2];
813  }
814  else {
815  m_sumEt_zz[m_l2Builder->idToIndex(fragId)] = sumE[0];
816  m_sumEz_zz[m_l2Builder->idToIndex(fragId)] = sumE[1];
817  m_sumE_zz[m_l2Builder->idToIndex(fragId)] = sumE[2];
818  }
819  }
820  }
821 
822  if (m_compareMode && dspCont) {
823 
824  const TileL2Container* l2Cnt = SG::makeHandle(m_l2CntKey, ctx).get();
825 
826  TileL2Container::const_iterator it = l2Cnt->begin();
827  TileL2Container::const_iterator end= l2Cnt->end();
828  int i=0;
829  for(; it != end; ++it) {
830  m_sumEt_yy[i++] = (*it)->sumEt();
831  m_sumEz_yy[i++] = (*it)->sumEz();
832  m_sumE_yy[i++] = (*it)->sumE();
833  }
834  }
835 
836  return StatusCode::SUCCESS;
837 }

◆ storeTMDBDecision()

StatusCode TileAANtuple::storeTMDBDecision ( const EventContext &  ctx)
private

Definition at line 1230 of file TileAANtuple.cxx.

1230  {
1231 
1232  const char * part[4] = {"LBA","LBC","EBA","EBC"};
1233 
1234  // Read Decision from TES
1235  //
1236  if (!m_tileMuRcvContainerKey.empty()){
1237 
1238  ATH_MSG_VERBOSE( "reading TMDB decision from " << m_tileMuRcvContainerKey.key() );
1239 
1240  const TileMuonReceiverContainer *decisionCnt =
1241  SG::makeHandle (m_tileMuRcvContainerKey, ctx).get();
1242 
1243  TileMuonReceiverContainer::const_iterator it = decisionCnt->begin();
1244  TileMuonReceiverContainer::const_iterator itLast = decisionCnt->end();
1245 
1246  // Go through all decisions
1247  //
1248  int bcid[3]={0};
1249 
1250  for(; it != itLast; ++it) {
1251 
1252  const TileMuonReceiverObj * obj = (*it);
1253 
1254  const std::vector<bool> & decision = obj->GetDecision();
1255  int siz = decision.size();
1256 
1257  if (siz>0) {
1258 
1259  int fragId = (*it)->identify();
1260  int drawer = fragId & 0x3F;
1261  int ros = ((fragId>>8) & 0xF) - 1;
1262  bcid[2] = ((fragId>>24) & 0xF);
1263  bcid[1] = ((fragId>>20) & 0xF);
1264  bcid[0] = ((fragId>>16) & 0XF);
1265 
1266  if (siz > N_TMDBDECISIONS) {
1267  ATH_MSG_VERBOSE( "TMDB ONLY " << N_TMDBDECISIONS << " decisions saved to ntuple instead of " << siz);
1268  siz = N_TMDBDECISIONS;
1269  }
1270 
1271  for (int n = 0; n < siz; ++n) {
1272  m_arrays->m_decisionTMDB[ros][drawer][n] = (unsigned char) decision[n];
1273  }
1274 
1275  for (int n = 0; n < 3; ++n) {
1276  m_arrays->m_bcidTMDB[ros][drawer][n] = (unsigned char) bcid[n];
1277  }
1278 
1279  if (msgLvl(MSG::VERBOSE)) {
1280  std::stringstream ss;
1281  for (int n = 0; n < siz; ++n) {
1282  ss<<std::setw(5)<<(int)m_arrays->m_decisionTMDB[ros][drawer][n];
1283  }
1284  ATH_MSG_VERBOSE( "TMDB 0x" <<MSG::hex<< fragId <<MSG::dec<<" "<< part[ros]
1285  << std::setfill('0') << std::setw(2)
1286  << drawer+1 << std::setfill(' ')
1287  << " BCID check " << bcid[0] <<"/"<< bcid[1] <<"/"<< bcid[2] << " decision: " << ss.str() );
1288  }
1289  }
1290  }
1291  }
1292 
1293  return StatusCode::SUCCESS;
1294 }

◆ storeTMDBDigits()

StatusCode TileAANtuple::storeTMDBDigits ( const EventContext &  ctx)
private

Definition at line 1296 of file TileAANtuple.cxx.

1296  {
1297 
1298  const char * part[4] = {"LBA","LBC","EBA","EBC"};
1299 
1300  // Read Digits from TES
1301  //
1302  if (!m_tileMuRcvDigitsContainerKey.empty()){
1303 
1304  ATH_MSG_VERBOSE( "reading TMDB digits from " << m_tileMuRcvDigitsContainerKey.key() );
1305 
1306  const TileDigitsContainer* digitsCnt =
1307  SG::makeHandle (m_tileMuRcvDigitsContainerKey, ctx).get();
1308 
1309  TileDigitsContainer::const_iterator itColl1 = (*digitsCnt).begin();
1310  TileDigitsContainer::const_iterator itCollEnd1 = (*digitsCnt).end();
1311 
1312  // Go through all TileDigitsCollections
1313  for(; itColl1 != itCollEnd1; ++itColl1) {
1314 
1315  TileDigitsCollection::const_iterator it1 = (*itColl1)->begin();
1316  TileDigitsCollection::const_iterator itEnd1 = (*itColl1)->end();
1317 
1318  if (it1!=itEnd1) {
1319 
1320  int fragId = (*itColl1)->identify();
1321  int drawer = fragId & 0x3F;
1322  int ros = (fragId>>8) - 1;
1323  int ichannel = 0;
1324 
1325  ATH_MSG_VERBOSE( "TMDB 0x" <<MSG::hex<< fragId <<MSG::dec<<" "<< part[ros]
1326  << std::setfill('0') << std::setw(2)
1327  << drawer+1 << std::setfill(' ') );
1328 
1329  for (; it1 != itEnd1; ++it1) {
1330 
1331  if (ichannel>=N_TMDBCHANS) {
1332  ATH_MSG_WARNING("Too many channels in TMDB Digi container for frag 0x" <<MSG::hex<< fragId <<MSG::dec <<" keeping only first " << N_TMDBCHANS << " channels in ntuple ");
1333  break;
1334  }
1335 
1336  const TileDigits* digit = (*it1);
1337 
1338  // get digits
1339  const std::vector<float> & sampleVec = digit->samples();
1340  int siz = sampleVec.size();
1341 
1342  if (siz > m_nSamples) {
1343  ATH_MSG_VERBOSE( "TMDB ONLY " << m_nSamples << " digits saved to ntuple instead of " << siz);
1344  siz = m_nSamples;
1345  }
1346 
1347  for (int n = 0; n < siz; ++n) {
1348  m_arrays->m_sampleTMDB[sample_ind_TMDB(ros,drawer,ichannel,n)] = (unsigned char) sampleVec[n];
1349  }
1350 
1351  if (msgLvl(MSG::VERBOSE)) {
1352  std::stringstream ss;
1353  for (int n = 0; n < siz; ++n) {
1354  ss<<std::setw(5)<<(int)m_arrays->m_sampleTMDB[sample_ind_TMDB(ros,drawer,ichannel,n)];
1355  }
1356  ATH_MSG_VERBOSE( "TMDB dig: " <<ros+1<<"/"<<drawer<<"/"<<m_tileHWID->channel(digit->adc_HWID())<<": "<<ss.str() );
1357  }
1358 
1359  ++ichannel;
1360  }
1361  }
1362  }
1363  }
1364 
1365  return StatusCode::SUCCESS;
1366 }

◆ storeTMDBRawChannel()

StatusCode TileAANtuple::storeTMDBRawChannel ( const EventContext &  ctxx)
private

Definition at line 1368 of file TileAANtuple.cxx.

1368  {
1369 
1370  const char * part[4] = {"LBA","LBC","EBA","EBC"};
1371 
1372  // Read Raw Channels from TDS
1373  //
1374  if (!m_tileMuRcvRawChannelContainerKey.empty()){
1375 
1376  ATH_MSG_VERBOSE( "reading TMDB energies from " << m_tileMuRcvRawChannelContainerKey.key() );
1377 
1378  const TileRawChannelContainer* rcCnt =
1379  SG::makeHandle (m_tileMuRcvRawChannelContainerKey, ctx).get();
1380 
1381  TileRawChannelContainer::const_iterator itColl2 = (*rcCnt).begin();
1382  TileRawChannelContainer::const_iterator itCollEnd2 = (*rcCnt).end();
1383 
1384  // Go through all TileDigitsCollections
1385  for(; itColl2 != itCollEnd2; ++itColl2) {
1386 
1387  TileRawChannelCollection::const_iterator it2 = (*itColl2)->begin();
1388  TileRawChannelCollection::const_iterator itEnd2 = (*itColl2)->end();
1389 
1390  if (it2!=itEnd2) {
1391 
1392  int fragId = (*itColl2)->identify();
1393  int drawer = fragId & 0x3F;
1394  int ros = (fragId>>8) - 1;
1395  int ichannel = 0;
1396 
1397  ATH_MSG_VERBOSE( "TMDB 0x" <<MSG::hex<< fragId <<MSG::dec<<" "<< part[ros]
1398  << std::setfill('0') << std::setw(2)
1399  << drawer+1 << std::setfill(' ') );
1400 
1401  for (; it2 != itEnd2; ++it2) {
1402 
1403  if (ichannel>=N_TMDBCHANS) {
1404  ATH_MSG_WARNING("Too many channels in TMDB RCh container for frag 0x" <<MSG::hex<< fragId <<MSG::dec <<" keeping only first " << N_TMDBCHANS << " channels in ntuple ");
1405  break;
1406  }
1407 
1408  const TileRawChannel* rc = (*it2);
1409 
1410  m_arrays->m_eTMDB[ros][drawer][ichannel] = rc -> amplitude();
1411 
1412  ATH_MSG_VERBOSE( "TMDB rc: " <<ros+1<<"/"<<drawer<<"/"<<m_tileHWID->channel(rc->adc_HWID())<< ": " << m_arrays->m_eTMDB[ros][drawer][ichannel] );
1413 
1414  ++ichannel;
1415  }
1416  }
1417  }
1418  }
1419 
1420  return StatusCode::SUCCESS;
1421 }

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

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

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

◆ TMDB_addBranch()

void TileAANtuple::TMDB_addBranch ( void  )
private

Definition at line 2184 of file TileAANtuple.cxx.

2185 {
2186 
2187  if (!m_tileMuRcvRawChannelContainerKey.empty()) {
2188  m_ntuplePtr->Branch("eTMDB", m_arrays->m_eTMDB, "eTMDB[4][64][8]/F"); // float m_arrays->m_eTMDB[N_ROS][N_MODULES][N_TMDBCHANS]
2189  }
2190 
2191  if (!m_tileMuRcvDigitsContainerKey.empty()) {
2192  m_ntuplePtr->Branch("sampleTMDB", &(m_arrays->m_sampleTMDB[0]), NAME3("sampleTMDB[4][64][8][",std::to_string(m_nSamples),"]/b")); // unsigned char m_arrays->m_sampleTMDB[N_ROS][N_MODULES][N_TMDBCHANS][N_SAMPLES]
2193  }
2194 
2195  if (!m_tileMuRcvContainerKey.empty()) {
2196  m_ntuplePtr->Branch("decisionTMDB", m_arrays->m_decisionTMDB, "decisionTMDB[4][64][4]/b"); // unsigned char m_arrays->m_decisionTMDB[N_ROS][N_MODULES][N_TMDBDECISIONS]
2197  }
2198 
2199  if (!m_tileMuRcvContainerKey.empty()) {
2200  m_ntuplePtr->Branch("bcidTMDB", m_arrays->m_bcidTMDB, "bcidTMDB[4][64][3]/b"); // unsigned char m_arrays->m_bcidTMDB[N_ROS][N_MODULES][N_TMDBBCIDWORDS]
2201  }
2202 
2203 }

◆ TMDB_clearBranch()

void TileAANtuple::TMDB_clearBranch ( void  )
private

Definition at line 2205 of file TileAANtuple.cxx.

2206 {
2207  if (!m_tileMuRcvRawChannelContainerKey.empty()) CLEAR(m_arrays->m_eTMDB);
2208  if (!m_tileMuRcvDigitsContainerKey.empty()) CLEAR6(m_arrays->m_sampleTMDB);
2209  if (!m_tileMuRcvContainerKey.empty()) CLEAR(m_arrays->m_decisionTMDB);
2210  if (!m_tileMuRcvContainerKey.empty()) CLEAR(m_arrays->m_bcidTMDB);
2211 }

◆ TRIGGER_addBranch()

void TileAANtuple::TRIGGER_addBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// /Add TRIGGER variables to the Tree

////////////////////////////////////////////////////////////////////////////

Definition at line 1636 of file TileAANtuple.cxx.

1636  {
1637  m_ntuplePtr->Branch("EvTime",&m_evTime,"EvTime/I");
1638  m_ntuplePtr->Branch("Run",&m_run,"Run/I");
1639  m_ntuplePtr->Branch("LumiBlock",&m_lumiBlock,"LumiBlock/I");
1640  m_ntuplePtr->Branch("Evt",&m_evt,"Evt/I");
1641  m_ntuplePtr->Branch("EvtNr",&m_evtNr,"EvtNr/I");
1642  m_ntuplePtr->Branch("Trig",&m_trigType,"Trig/I");
1643  m_ntuplePtr->Branch("DSPflags",&m_dspFlags,"DSPflags/i");
1644  m_ntuplePtr->Branch("DSPunits",&m_dspUnit,"DSPunits/S");
1645  m_ntuplePtr->Branch("OFLunits",&m_rchUnit,"OFLunits/S");
1646 
1647  if (m_bsInput) {
1648  std::string dim = "[" + std::to_string(N_RODS) + "]/I";
1649  m_ntuplePtr->Branch("L1ID", m_l1ID, NAME2("L1ID", dim));
1650  m_ntuplePtr->Branch("L1Type", m_l1Type, NAME2("L1Type",dim));
1651  m_ntuplePtr->Branch("EvType", m_evType, NAME2("EvType",dim));
1652  m_ntuplePtr->Branch("EvBCID", m_evBCID, NAME2("EvBCID",dim));
1653  }
1654 }

◆ TRIGGER_clearBranch()

void TileAANtuple::TRIGGER_clearBranch ( void  )
private

//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER variables

////////////////////////////////////////////////////////////////////////////

Definition at line 1663 of file TileAANtuple.cxx.

1663  {
1664  m_evTime=0;
1665  m_run=0;
1666  m_evt=0;
1667  m_trigType=0;
1668  m_dspFlags=0;
1669 
1670  CLEAR1(m_l1ID);
1671  CLEAR1(m_l1Type);
1672  CLEAR1(m_evType);
1673  CLEAR1(m_evBCID);
1674 }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_arrays

std::unique_ptr<Arrays> TileAANtuple::m_arrays
private

Definition at line 338 of file TileAANtuple.h.

◆ m_bad

bool TileAANtuple::m_bad[N_ROS][N_MODULES][N_CHANS]
private

Definition at line 426 of file TileAANtuple.h.

◆ m_beamElemContainerKey

SG::ReadHandleKey<TileBeamElemContainer> TileAANtuple::m_beamElemContainerKey
private

Definition at line 356 of file TileAANtuple.h.

◆ m_bsInput

bool TileAANtuple::m_bsInput
private

true if bytestream file is used

Definition at line 375 of file TileAANtuple.h.

◆ m_cabling

const TileCablingService* TileAANtuple::m_cabling
private

cabling tool

Definition at line 406 of file TileAANtuple.h.

◆ m_cablingSvc

ServiceHandle<TileCablingSvc> TileAANtuple::m_cablingSvc
private
Initial value:
{ this,
"TileCablingSvc", "TileCablingSvc", "The Tile cabling service" }

Name of Tile cabling service.

Definition at line 435 of file TileAANtuple.h.

◆ m_calibMode

bool TileAANtuple::m_calibMode
private

If data should be put in calib mode.

Definition at line 378 of file TileAANtuple.h.

◆ m_calibrateEnergy

bool TileAANtuple::m_calibrateEnergy
private

convert energy to new units or use amplitude from RawChannel directly

Definition at line 373 of file TileAANtuple.h.

◆ m_checkDCS

bool TileAANtuple::m_checkDCS
private

if false, do not use TileDCS at all

Definition at line 380 of file TileAANtuple.h.

◆ m_cispar

uint32_t TileAANtuple::m_cispar[N_CISPAR]
private

Definition at line 206 of file TileAANtuple.h.

◆ m_compareMode

bool TileAANtuple::m_compareMode
private

If two sets of data should be compared (e.g.

frag4 and frag5)

Definition at line 379 of file TileAANtuple.h.

◆ m_compressSettings

int TileAANtuple::m_compressSettings
private

Definition at line 351 of file TileAANtuple.h.

◆ m_daqtype

int TileAANtuple::m_daqtype
private

Definition at line 342 of file TileAANtuple.h.

◆ m_dateTime

char TileAANtuple::m_dateTime[32]
private

event date and time

Definition at line 196 of file TileAANtuple.h.

◆ m_DCSBranches

int TileAANtuple::m_DCSBranches
private

mask like 110101 - which DCS branches to fill

Definition at line 381 of file TileAANtuple.h.

◆ m_DCSntuplePtr

TTree* TileAANtuple::m_DCSntuplePtr
private

Definition at line 394 of file TileAANtuple.h.

◆ m_decoder

ToolHandle<TileROD_Decoder> TileAANtuple::m_decoder
private
Initial value:
{this,
"TileROD_Decoder", "TileROD_Decoder", "Tile ROD decoder"}

Definition at line 441 of file TileAANtuple.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_digitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileAANtuple::m_digitsContainerKey
private

Definition at line 354 of file TileAANtuple.h.

◆ m_DQstatusKey

SG::ReadHandleKey<TileDQstatus> TileAANtuple::m_DQstatusKey
private
Initial value:
{ this,
"TileDQstatus", "TileDQstatus", "TileDQstatus key" }

Definition at line 444 of file TileAANtuple.h.

◆ m_dspFlags

uint32_t TileAANtuple::m_dspFlags
private

DSP flags from BS.

Definition at line 198 of file TileAANtuple.h.

◆ m_dspRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_dspRawChannelContainerKey
private

Definition at line 362 of file TileAANtuple.h.

◆ m_dspUnit

TileRawChannelUnit::UNIT TileAANtuple::m_dspUnit
private

Unit for TileRawChannels in DSP.

Definition at line 385 of file TileAANtuple.h.

◆ m_evBCID

int TileAANtuple::m_evBCID[N_RODS]
private

Event BCID from ROD header.

Definition at line 202 of file TileAANtuple.h.

◆ m_evt

int TileAANtuple::m_evt
private

event number in a run

Definition at line 193 of file TileAANtuple.h.

◆ m_evTime

int TileAANtuple::m_evTime
private

event time

Definition at line 191 of file TileAANtuple.h.

◆ m_evtNr

int TileAANtuple::m_evtNr
private

event counter

Definition at line 188 of file TileAANtuple.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_evType

int TileAANtuple::m_evType[N_RODS]
private

Event Type from ROD header.

Definition at line 203 of file TileAANtuple.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_fileMgr

ServiceHandle<IFileMgr> TileAANtuple::m_fileMgr
private
Initial value:
{this,
"FileMgr", "FileMgr", "The File manager service" }

Definition at line 398 of file TileAANtuple.h.

◆ m_finalUnit

int TileAANtuple::m_finalUnit
private

calibrate everything to this level

Definition at line 377 of file TileAANtuple.h.

◆ m_fitcRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_fitcRawChannelContainerKey
private

Definition at line 359 of file TileAANtuple.h.

◆ m_fitRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_fitRawChannelContainerKey
private

Definition at line 358 of file TileAANtuple.h.

◆ m_fltDigitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileAANtuple::m_fltDigitsContainerKey
private

Definition at line 355 of file TileAANtuple.h.

◆ m_HHMMSS

int TileAANtuple::m_HHMMSS
private

event time in HH:MM:SS

Definition at line 195 of file TileAANtuple.h.

◆ m_l1ID

int TileAANtuple::m_l1ID[N_RODS]
private

Level1 ID from ROD header.

Definition at line 200 of file TileAANtuple.h.

◆ m_l1Type

int TileAANtuple::m_l1Type[N_RODS]
private

Level1 Type from ROD header.

Definition at line 201 of file TileAANtuple.h.

◆ m_l2Builder

ToolHandle<TileL2Builder> TileAANtuple::m_l2Builder
private

Definition at line 416 of file TileAANtuple.h.

◆ m_l2CntKey

SG::ReadHandleKey<TileL2Container> TileAANtuple::m_l2CntKey
private

Definition at line 370 of file TileAANtuple.h.

◆ m_las_BCID

int TileAANtuple::m_las_BCID
private

Definition at line 210 of file TileAANtuple.h.

◆ m_las_Filt

int TileAANtuple::m_las_Filt
private

Definition at line 212 of file TileAANtuple.h.

◆ m_las_MeasAmp

float TileAANtuple::m_las_MeasAmp
private

Definition at line 214 of file TileAANtuple.h.

◆ m_las_ReqAmp

float TileAANtuple::m_las_ReqAmp
private

Definition at line 213 of file TileAANtuple.h.

◆ m_las_Temperature

float TileAANtuple::m_las_Temperature
private

Definition at line 215 of file TileAANtuple.h.

◆ m_las_version

int TileAANtuple::m_las_version
private

Definition at line 209 of file TileAANtuple.h.

◆ m_laserObjectKey

SG::ReadHandleKey<TileLaserObject> TileAANtuple::m_laserObjectKey
private

Definition at line 366 of file TileAANtuple.h.

◆ m_lumiBlock

int TileAANtuple::m_lumiBlock
private

lumiblock number in a run

Definition at line 194 of file TileAANtuple.h.

◆ m_mfRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_mfRawChannelContainerKey
private

Definition at line 363 of file TileAANtuple.h.

◆ m_nBadDB

int TileAANtuple::m_nBadDB
private

Definition at line 346 of file TileAANtuple.h.

◆ m_nBadDCS

int TileAANtuple::m_nBadDCS
private

Definition at line 345 of file TileAANtuple.h.

◆ m_nBadDr

int TileAANtuple::m_nBadDr
private

Definition at line 343 of file TileAANtuple.h.

◆ m_nBadHV

int TileAANtuple::m_nBadHV
private

Definition at line 344 of file TileAANtuple.h.

◆ m_nBadTotal

int TileAANtuple::m_nBadTotal
private

Definition at line 347 of file TileAANtuple.h.

◆ m_nSamples

int TileAANtuple::m_nSamples =0
private

number of samples

Definition at line 349 of file TileAANtuple.h.

◆ m_ntupleID

std::string TileAANtuple::m_ntupleID
private

Definition at line 389 of file TileAANtuple.h.

◆ m_ntuplePtr

TTree* TileAANtuple::m_ntuplePtr
private

Definition at line 393 of file TileAANtuple.h.

◆ m_of1RawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_of1RawChannelContainerKey
private

Definition at line 364 of file TileAANtuple.h.

◆ m_optRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_optRawChannelContainerKey
private

Definition at line 360 of file TileAANtuple.h.

◆ m_pmtOrder

bool TileAANtuple::m_pmtOrder
private

change channel ordering to pmt ordering in ntuple

Definition at line 376 of file TileAANtuple.h.

◆ m_qdctimeout

bool TileAANtuple::m_qdctimeout
private

Definition at line 340 of file TileAANtuple.h.

◆ m_qieRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_qieRawChannelContainerKey
private

Definition at line 361 of file TileAANtuple.h.

◆ m_rawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_rawChannelContainerKey
private

Definition at line 357 of file TileAANtuple.h.

◆ m_rchUnit

TileRawChannelUnit::UNIT TileAANtuple::m_rchUnit
private

Unit for TileRawChannels (ADC, pCb, MeV)

Definition at line 384 of file TileAANtuple.h.

◆ m_reduced

bool TileAANtuple::m_reduced
private

Definition at line 350 of file TileAANtuple.h.

◆ m_ROBID

std::vector<uint32_t> TileAANtuple::m_ROBID
private

Definition at line 430 of file TileAANtuple.h.

◆ m_robSvc

ServiceHandle<IROBDataProviderSvc> TileAANtuple::m_robSvc
private
Initial value:
{this,
"ROBDataProviderSvc", "ROBDataProviderSvc", "The ROB data provider service" }

Definition at line 438 of file TileAANtuple.h.

◆ m_run

int TileAANtuple::m_run
private

run number

Definition at line 192 of file TileAANtuple.h.

◆ m_skipEvents

int TileAANtuple::m_skipEvents
private

Definition at line 428 of file TileAANtuple.h.

◆ m_streamName

std::string TileAANtuple::m_streamName
private

Definition at line 388 of file TileAANtuple.h.

◆ m_sumE_xx

float TileAANtuple::m_sumE_xx[N_DRAWERS]
private

Sum E recalculated offline using DSP raw channels.

Definition at line 419 of file TileAANtuple.h.

◆ m_sumE_yy

float TileAANtuple::m_sumE_yy[N_DRAWERS]
private

Sum E calcualted inside DSP.

Definition at line 422 of file TileAANtuple.h.

◆ m_sumE_zz

float TileAANtuple::m_sumE_zz[N_DRAWERS]
private

Sum E recalculated offline using offline OF.

Definition at line 425 of file TileAANtuple.h.

◆ m_sumEt_xx

float TileAANtuple::m_sumEt_xx[N_DRAWERS]
private

Sum Et recalculated offline using DSP raw channels.

Definition at line 417 of file TileAANtuple.h.

◆ m_sumEt_yy

float TileAANtuple::m_sumEt_yy[N_DRAWERS]
private

Sum Et calcualted inside DSP.

Definition at line 420 of file TileAANtuple.h.

◆ m_sumEt_zz

float TileAANtuple::m_sumEt_zz[N_DRAWERS]
private

Sum Et recalculated offline using offline OF.

Definition at line 423 of file TileAANtuple.h.

◆ m_sumEz_xx

float TileAANtuple::m_sumEz_xx[N_DRAWERS]
private

Sum Ez recalculated offline using DSP raw channels.

Definition at line 418 of file TileAANtuple.h.

◆ m_sumEz_yy

float TileAANtuple::m_sumEz_yy[N_DRAWERS]
private

Sum Ez calcualted inside DSP.

Definition at line 421 of file TileAANtuple.h.

◆ m_sumEz_zz

float TileAANtuple::m_sumEz_zz[N_DRAWERS]
private

Sum Ez recalculated offline using offline OF.

Definition at line 424 of file TileAANtuple.h.

◆ m_tdctimeout

bool TileAANtuple::m_tdctimeout
private

Definition at line 341 of file TileAANtuple.h.

◆ m_thistSvc

ServiceHandle<ITHistSvc> TileAANtuple::m_thistSvc
private

Definition at line 397 of file TileAANtuple.h.

◆ m_tileBadChanTool

ToolHandle<ITileBadChanTool> TileAANtuple::m_tileBadChanTool
private

Tile Bad Channel tool.

Definition at line 409 of file TileAANtuple.h.

◆ m_tileDCS

ToolHandle<ITileDCSTool> TileAANtuple::m_tileDCS {this, "TileDCSTool", "TileDCSTool", "Tile DCS tool"}
private

Definition at line 413 of file TileAANtuple.h.

◆ m_tileHWID

const TileHWID* TileAANtuple::m_tileHWID
private

Definition at line 403 of file TileAANtuple.h.

◆ m_tileID

const TileID* TileAANtuple::m_tileID
private

Definition at line 402 of file TileAANtuple.h.

◆ m_tileMgr

const TileDetDescrManager* TileAANtuple::m_tileMgr
private

Pointer to TileDetDescrManager.

Definition at line 407 of file TileAANtuple.h.

◆ m_tileMuRcvContainerKey

SG::ReadHandleKey<TileMuonReceiverContainer> TileAANtuple::m_tileMuRcvContainerKey
private

Definition at line 369 of file TileAANtuple.h.

◆ m_tileMuRcvDigitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileAANtuple::m_tileMuRcvDigitsContainerKey
private

Definition at line 368 of file TileAANtuple.h.

◆ m_tileMuRcvRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_tileMuRcvRawChannelContainerKey
private

Definition at line 367 of file TileAANtuple.h.

◆ m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileAANtuple::m_tileToolEmscale
private

main Tile Calibration tool

Definition at line 411 of file TileAANtuple.h.

◆ m_treeSize

int64_t TileAANtuple::m_treeSize
private

Definition at line 390 of file TileAANtuple.h.

◆ m_trigType

int TileAANtuple::m_trigType
private

trigger type (1=Phys, 2=Laser, 4=Ped, 8=CIS)

Definition at line 197 of file TileAANtuple.h.

◆ m_useDspUnits

bool TileAANtuple::m_useDspUnits
private

true if energy should be converted to units used in DSP

Definition at line 374 of file TileAANtuple.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.

◆ m_wienerRawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileAANtuple::m_wienerRawChannelContainerKey
private

Definition at line 365 of file TileAANtuple.h.

The documentation for this class was generated from the following files:
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileAANtuple::TMDB_clearBranch
void TMDB_clearBranch(void)
Definition: TileAANtuple.cxx:2205
bad
@ bad
Definition: SUSYToolsTester.cxx:100
TileRawChannelContainer
Definition: TileRawChannelContainer.h:13
TileAANtuple::m_dateTime
char m_dateTime[32]
event date and time
Definition: TileAANtuple.h:196
CaloDetDescrElement::onl2
IdentifierHash onl2() const
cell online identifier 2
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:408
TileAANtuple::m_checkDCS
bool m_checkDCS
if false, do not use TileDCS at all
Definition: TileAANtuple.h:380
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
TileLaserObject::getTDC
int getTDC(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:209
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
TileAANtuple::m_sumE_yy
float m_sumE_yy[N_DRAWERS]
Sum E calcualted inside DSP.
Definition: TileAANtuple.h:422
xAOD::short
short
Definition: Vertex_v1.cxx:165
yodamerge_tmp.dim
dim
Definition: yodamerge_tmp.py:239
TileAANtuple::m_ntupleID
std::string m_ntupleID
Definition: TileAANtuple.h:389
header
Definition: hcg.cxx:526
CLEAR2
#define CLEAR2(array, size)
Definition: TileAANtuple.cxx:72
TileAANtuple::m_dspUnit
TileRawChannelUnit::UNIT m_dspUnit
Unit for TileRawChannels in DSP.
Definition: TileAANtuple.h:385
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
TileAANtuple::storeTMDBDigits
StatusCode storeTMDBDigits(const EventContext &ctx)
Definition: TileAANtuple.cxx:1296
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
N_ROS
#define N_ROS
Filename : TileAANtuple.h Author : Alexander Solodkov (based on TileTBAANtuple) Created : April,...
Definition: TileAANtuple.h:72
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
CLEAR6
#define CLEAR6(array)
Definition: TileAANtuple.cxx:87
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileAANtuple::m_DCSntuplePtr
TTree * m_DCSntuplePtr
Definition: TileAANtuple.h:394
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
index
Definition: index.py:1
N_DMUS
#define N_DMUS
Definition: TileAANtuple.h:76
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileLaserObject::nbGains
@ nbGains
Definition: TileLaserObject.h:44
TileAANtuple::m_lumiBlock
int m_lumiBlock
lumiblock number in a run
Definition: TileAANtuple.h:194
TileLaserObject::isLASERII
bool isLASERII() const
Definition: TileLaserObject.h:214
TileLaserObject::getPumpDiodeTemp
double getPumpDiodeTemp() const
Definition: TileLaserObject.h:234
TileAANtuple::m_reduced
bool m_reduced
Definition: TileAANtuple.h:350
TileRawChannel::pedestal
float pedestal(void) const
Definition: TileRawChannel.h:106
ReadBchFromCool.pmt
pmt
Definition: ReadBchFromCool.py:62
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
TileHid2RESrcID::getRobFromFragID
uint32_t getRobFromFragID(int frag_id) const
make a ROB SrcID for a fragment ID
Definition: TileHid2RESrcID.cxx:457
TileAANtuple::m_decoder
ToolHandle< TileROD_Decoder > m_decoder
Definition: TileAANtuple.h:441
TileAANtuple::fillCellMap
void fillCellMap(TTree *ntuplePtr)
///////////////////////////////////////////////////////////////////////////
Definition: TileAANtuple.cxx:1534
TileDQstatus::calibMode
uint32_t calibMode() const
Calibration mode.
Definition: TileDQstatus.h:148
TileAANtuple::m_l2Builder
ToolHandle< TileL2Builder > m_l2Builder
Definition: TileAANtuple.h:416
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
xAOD::char
char
Definition: TrigDecision_v1.cxx:38
ViewHelper::makeHandle
SG::ReadHandle< T > makeHandle(const SG::View *view, const SG::ReadHandleKey< T > &rhKey, const EventContext &context)
navigate from the TrigComposite to nearest view and fetch object from it
Definition: ViewHelper.h:265
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TileAANtuple::m_finalUnit
int m_finalUnit
calibrate everything to this level
Definition: TileAANtuple.h:377
TileBchStatus
Class holding bad channel problems.
Definition: TileBchStatus.h:20
sample_ind_TMDB
#define sample_ind_TMDB(r, m, c, i)
Definition: TileAANtuple.cxx:104
TileAANtuple::m_HHMMSS
int m_HHMMSS
event time in HH:MM:SS
Definition: TileAANtuple.h:195
TileAANtuple::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: TileAANtuple.h:397
skel.it
it
Definition: skel.GENtoEVGEN.py:396
TileLaserObject::getAlpha
double getAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:138
N_RODS
#define N_RODS
Definition: TileAANtuple.h:79
TileAANtuple::m_evBCID
int m_evBCID[N_RODS]
Event BCID from ROD header.
Definition: TileAANtuple.h:202
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
pool::WRITE
@ WRITE
Definition: Database/APR/StorageSvc/StorageSvc/pool.h:72
TileAANtuple::m_compareMode
bool m_compareMode
If two sets of data should be compared (e.g.
Definition: TileAANtuple.h:379
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
TileAANtuple::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Tile Bad Channel tool.
Definition: TileAANtuple.h:409
TileAANtuple::initNTuple
StatusCode initNTuple(const EventContext &ctx)
Definition: TileAANtuple.cxx:1449
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TileAANtuple::m_nBadDCS
int m_nBadDCS
Definition: TileAANtuple.h:345
TileLaserObject::getDiodeCurrOrd
double getDiodeCurrOrd() const
Definition: TileLaserObject.h:219
CLEAR4
#define CLEAR4(array, size)
Definition: TileAANtuple.cxx:79
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileAANtuple::m_cablingSvc
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.
Definition: TileAANtuple.h:435
N_ROS2
#define N_ROS2
Definition: TileAANtuple.h:73
DIGI_PAR_FRAG
#define DIGI_PAR_FRAG
Definition: TileTBFrag.h:41
TileAANtuple::m_sumEz_xx
float m_sumEz_xx[N_DRAWERS]
Sum Ez recalculated offline using DSP raw channels.
Definition: TileAANtuple.h:418
TileAANtuple::m_pmtOrder
bool m_pmtOrder
change channel ordering to pmt ordering in ntuple
Definition: TileAANtuple.h:376
TileCablingService::h2s_cell_id_index
Identifier h2s_cell_id_index(const HWIdentifier &id, int &index, int &pmt) const
Definition: TileCablingService.cxx:2418
TileAANtuple::m_laserObjectKey
SG::ReadHandleKey< TileLaserObject > m_laserObjectKey
Definition: TileAANtuple.h:366
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
TileAANtuple::m_ROBID
std::vector< uint32_t > m_ROBID
Definition: TileAANtuple.h:430
TileAANtuple::m_calibrateEnergy
bool m_calibrateEnergy
convert energy to new units or use amplitude from RawChannel directly
Definition: TileAANtuple.h:373
TileAANtuple::m_las_BCID
int m_las_BCID
Definition: TileAANtuple.h:210
TileAANtuple::m_sumE_xx
float m_sumE_xx[N_DRAWERS]
Sum E recalculated offline using DSP raw channels.
Definition: TileAANtuple.h:419
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileAANtuple::m_skipEvents
int m_skipEvents
Definition: TileAANtuple.h:428
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
TileAANtuple::m_sumEt_xx
float m_sumEt_xx[N_DRAWERS]
Sum Et recalculated offline using DSP raw channels.
Definition: TileAANtuple.h:417
TileLaserObject::getVersion
int getVersion() const
Definition: TileLaserObject.h:209
TileDigitsContainer
Definition: TileDigitsContainer.h:13
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
CLEAR5
#define CLEAR5(array, size)
Definition: TileAANtuple.cxx:83
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition: TileRawData.h:53
HWIdentifier
Definition: HWIdentifier.h:13
TileAANtuple::m_sumEz_zz
float m_sumEz_zz[N_DRAWERS]
Sum Ez recalculated offline using offline OF.
Definition: TileAANtuple.h:424
TileAANtuple::m_treeSize
int64_t m_treeSize
Definition: TileAANtuple.h:390
empty
bool empty(TH1 *h)
Definition: computils.cxx:295
TileRawChannel::time
float time(int ind=0) const
Definition: TileRawChannel.h:103
TileAANtuple::LASER_clearBranch
void LASER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree LASER variabl...
Definition: TileAANtuple.cxx:1808
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileLaserObject::isSet
bool isSet(int chan, int gain, int type) const
Definition: TileLaserObject.cxx:71
TileAANtuple::storeTMDBDecision
StatusCode storeTMDBDecision(const EventContext &ctx)
Definition: TileAANtuple.cxx:1230
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
TileAANtuple::m_evType
int m_evType[N_RODS]
Event Type from ROD header.
Definition: TileAANtuple.h:203
MbtsDetDescrManager
Definition: MbtsDetDescrManager.h:16
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
TileHid2RESrcID
This class provides conversion between fragment ID and RESrcID.
Definition: TileHid2RESrcID.h:28
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TileAANtuple::m_wienerRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_wienerRawChannelContainerKey
Definition: TileAANtuple.h:365
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TileAANtuple::m_DCSBranches
int m_DCSBranches
mask like 110101 - which DCS branches to fill
Definition: TileAANtuple.h:381
TileAANtuple::m_evtNr
int m_evtNr
event counter
Definition: TileAANtuple.h:188
TileLaserObject::getPMADC
int getPMADC(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:195
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
TileAANtuple::storeBeamElements
StatusCode storeBeamElements(const TileDQstatus &DQstatus)
Definition: TileAANtuple.cxx:601
TileLaserObject::getFiltNumber
int getFiltNumber() const
Definition: TileLaserObject.h:229
TileAANtuple::storeTMDBRawChannel
StatusCode storeTMDBRawChannel(const EventContext &ctxx)
Definition: TileAANtuple.cxx:1368
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TileLaserObject::getSigmaPedAlpha
double getSigmaPedAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:180
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
CaloDetDescrElement::onl1
IdentifierHash onl1() const
cell online identifier 1
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:404
TileAANtuple::storeMFRawChannels
StatusCode storeMFRawChannels(const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, float *ene, float *time, float chi2[N_ROS2][N_MODULES][N_CHANS], float ped[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
Definition: TileAANtuple.cxx:840
TileRawChannel::quality
float quality(int ind=0) const
Definition: TileRawChannel.h:105
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TileAANtuple::LASER_addBranch
void LASER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree LASER variable...
Definition: TileAANtuple.cxx:1709
WriteCellNoiseToCool.gn
gn
Definition: WriteCellNoiseToCool.py:531
TileAANtuple::m_evTime
int m_evTime
event time
Definition: TileAANtuple.h:191
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:63
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileAANtuple::m_cabling
const TileCablingService * m_cabling
cabling tool
Definition: TileAANtuple.h:406
NAME3
#define NAME3(s1, s2, s3)
Definition: TileAANtuple.cxx:96
TileAANtuple::m_sumEt_zz
float m_sumEt_zz[N_DRAWERS]
Sum Et recalculated offline using offline OF.
Definition: TileAANtuple.h:423
TileLaserObject::getMean
double getMean(int chan, int gain, int type) const
Definition: TileLaserObject.cxx:41
TileDetDescrManager::tile_cell_begin
calo_element_const_iterator tile_cell_begin() const
Definition: TileDetDescrManager.h:147
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
TileAANtuple::m_fitRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitRawChannelContainerKey
Definition: TileAANtuple.h:358
TileLaserObject::getTDCTimeout
bool getTDCTimeout() const
Definition: TileLaserObject.h:319
AthCommonDataStore
Definition: AthCommonDataStore.h:52
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition: TileRawChannel.h:101
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileAANtuple::m_of1RawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_of1RawChannelContainerKey
Definition: TileAANtuple.h:364
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
TileAANtuple::storeDCS
StatusCode storeDCS()
Definition: TileAANtuple.cxx:2252
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:113
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
TileAANtuple::m_compressSettings
int m_compressSettings
Definition: TileAANtuple.h:351
eformat::ROBFragment< const uint32_t * >
TileAANtuple::ntuple_initialize
StatusCode ntuple_initialize(const EventContext &ctx, const TileDQstatus &DQstatus)
Definition: TileAANtuple.cxx:275
lumiFormat.i
int i
Definition: lumiFormat.py:85
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
python.LArBadChannelDBAlg.xFFFFFFFF
xFFFFFFFF
Definition: LArBadChannelDBAlg.py:73
TileAANtuple::m_calibMode
bool m_calibMode
If data should be put in calib mode.
Definition: TileAANtuple.h:378
beamspotman.n
n
Definition: beamspotman.py:731
DetDescrDictionaryDict::it1
std::vector< HWIdentifier >::iterator it1
Definition: DetDescrDictionaryDict.h:17
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileRawDataContainer::get_bsflags
uint32_t get_bsflags() const
Definition: TileRawDataContainer.h:64
TileRawChannelUnit::OnlineOffset
@ OnlineOffset
Definition: TileRawChannelUnit.h:25
N_CHANS
#define N_CHANS
Definition: TileAANtuple.h:77
TileAANtuple::m_dspRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_dspRawChannelContainerKey
Definition: TileAANtuple.h:362
TileAANtuple::TRIGGER_clearBranch
void TRIGGER_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree TRIGGER varia...
Definition: TileAANtuple.cxx:1663
TileAANtuple::m_cispar
uint32_t m_cispar[N_CISPAR]
Definition: TileAANtuple.h:206
generateReferenceFile.files
files
Definition: generateReferenceFile.py:12
CLEAR3
#define CLEAR3(array, size)
Definition: TileAANtuple.cxx:75
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
CLEAR1
#define CLEAR1(array)
Definition: TileAANtuple.cxx:69
TileDCSState::OK_DRAWER
@ OK_DRAWER
Definition: TileDCSState.h:33
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:523
TileAANtuple::m_rawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerKey
Definition: TileAANtuple.h:357
TileRawChannel
Definition: TileRawChannel.h:35
TileAANtuple::m_bsInput
bool m_bsInput
true if bytestream file is used
Definition: TileAANtuple.h:375
file
TFile * file
Definition: tile_monitor.h:29
TileAANtuple::m_nBadDB
int m_nBadDB
Definition: TileAANtuple.h:346
TileDetDescrManager::tile_cell_end
calo_element_const_iterator tile_cell_end() const
Definition: TileDetDescrManager.h:150
TileAANtuple::CISPAR_clearBranch
void CISPAR_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// Clear Tree CISPAR variab...
Definition: TileAANtuple.cxx:1696
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TileAANtuple::m_sumE_zz
float m_sumE_zz[N_DRAWERS]
Sum E recalculated offline using offline OF.
Definition: TileAANtuple.h:425
TileAANtuple::m_optRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_optRawChannelContainerKey
Definition: TileAANtuple.h:360
MbtsDetDescrManager::get_element
CaloDetDescrElement * get_element(const Identifier &elementId) const
Definition: MbtsDetDescrManager.cxx:22
TrigInDetValidation_Base.malloc
malloc
Definition: TrigInDetValidation_Base.py:132
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:79
TileAANtuple::storeRawChannels
StatusCode storeRawChannels(const EventContext &ctx, const SG::ReadHandleKey< TileRawChannelContainer > &containerKey, float ene[N_ROS2][N_MODULES][N_CHANS], float time[N_ROS2][N_MODULES][N_CHANS], float chi2[N_ROS2][N_MODULES][N_CHANS], float ped[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
/ Fill ntuple with data from TRC.
Definition: TileAANtuple.cxx:642
TileAANtuple::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
main Tile Calibration tool
Definition: TileAANtuple.h:411
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TileAANtuple::m_ntuplePtr
TTree * m_ntuplePtr
Definition: TileAANtuple.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
RunTileMonitoring.rod
rod
Definition: RunTileMonitoring.py:134
imax
int imax(int i, int j)
Definition: TileLaserTimingTool.cxx:33
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
python.IoTestsLib.ROOT
def ROOT
Definition: IoTestsLib.py:71
TileAANtuple::m_las_MeasAmp
float m_las_MeasAmp
Definition: TileAANtuple.h:214
TileAANtuple::m_l2CntKey
SG::ReadHandleKey< TileL2Container > m_l2CntKey
Definition: TileAANtuple.h:370
TileAANtuple::m_tileID
const TileID * m_tileID
Definition: TileAANtuple.h:402
TileAANtuple::m_las_version
int m_las_version
Definition: TileAANtuple.h:209
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
DQPostProcessTest.outFile
outFile
Comment Out Those You do not wish to run.
Definition: DQPostProcessTest.py:37
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TileHWID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: TileHWID.h:314
TileAANtuple::m_mfRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_mfRawChannelContainerKey
Definition: TileAANtuple.h:363
TileAANtuple::m_fileMgr
ServiceHandle< IFileMgr > m_fileMgr
Definition: TileAANtuple.h:398
TileLaserObject::getQDCTimeout
bool getQDCTimeout() const
Definition: TileLaserObject.h:314
TileAANtuple::m_sumEt_yy
float m_sumEt_yy[N_DRAWERS]
Sum Et calcualted inside DSP.
Definition: TileAANtuple.h:420
TileAANtuple::m_daqtype
int m_daqtype
Definition: TileAANtuple.h:342
TileLaserObject::getDiodeSigmaPedestal
double getDiodeSigmaPedestal(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:123
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TileAANtuple::m_dspFlags
uint32_t m_dspFlags
DSP flags from BS.
Definition: TileAANtuple.h:198
LASER_OBJ_FRAG
#define LASER_OBJ_FRAG
Definition: TileTBFrag.h:49
TileDigits
Definition: TileDigits.h:30
N_CISPAR
#define N_CISPAR
Definition: TileAANtuple.h:80
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
TileLaserObject::getBCID
int getBCID() const
Definition: TileLaserObject.h:335
TileLaserObject::getDiodeADC
int getDiodeADC(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:95
TileAANtuple::DIGI_addBranch
void DIGI_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree DIGI variables...
Definition: TileAANtuple.cxx:1854
TileAANtuple::m_streamName
std::string m_streamName
Definition: TileAANtuple.h:388
TileAANtuple::m_las_Filt
int m_las_Filt
Definition: TileAANtuple.h:212
TileAANtuple::m_bad
bool m_bad[N_ROS][N_MODULES][N_CHANS]
Definition: TileAANtuple.h:426
TileAANtuple::m_nBadHV
int m_nBadHV
Definition: TileAANtuple.h:344
TileAANtuple::m_tileMuRcvContainerKey
SG::ReadHandleKey< TileMuonReceiverContainer > m_tileMuRcvContainerKey
Definition: TileAANtuple.h:369
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
TileAANtuple::m_beamElemContainerKey
SG::ReadHandleKey< TileBeamElemContainer > m_beamElemContainerKey
Definition: TileAANtuple.h:356
TileLaserObject::getPMPedestal
double getPMPedestal(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:223
TileAANtuple::m_digitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_digitsContainerKey
Definition: TileAANtuple.h:354
TileAANtuple::m_fitcRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_fitcRawChannelContainerKey
Definition: TileAANtuple.h:359
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition: TileDQstatus.h:152
N_MODULES
#define N_MODULES
Definition: TileAANtuple.h:74
TileLaserObject::getDiodeCurrMeas
double getDiodeCurrMeas() const
Definition: TileLaserObject.h:224
Example_ReadSampleNoise.ped
ped
Definition: Example_ReadSampleNoise.py:45
PlotSFuncertainty.calib
calib
Definition: PlotSFuncertainty.py:110
TileAANtuple::m_run
int m_run
run number
Definition: TileAANtuple.h:192
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TileHWID::adc_id
HWIdentifier adc_id(int ros, int drawer, int channel, int adc) const
adc HWIdentifer
Definition: TileHWID.cxx:229
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
TileMuonReceiverObj
Definition: TileMuonReceiverObj.h:28
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition: TileCalibUtils.cxx:145
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
N_TMDBDECISIONS
#define N_TMDBDECISIONS
Definition: TileAANtuple.h:82
DeMoScan.index
string index
Definition: DeMoScan.py:364
TileAANtuple::DIGI_clearBranch
void DIGI_clearBranch(void)
//////////////////////////////////////////////////////////////////////////// /Clear Tree DIGI variabl...
Definition: TileAANtuple.cxx:2051
TileAANtuple::m_tileMgr
const TileDetDescrManager * m_tileMgr
Pointer to TileDetDescrManager.
Definition: TileAANtuple.h:407
TileRawData::cell_ID_index
Identifier cell_ID_index(int &index, int &pmt) const
Definition: TileRawData.cxx:65
a
TList * a
Definition: liststreamerinfos.cxx:10
TileAANtuple::ntuple_clear
StatusCode ntuple_clear()
Definition: TileAANtuple.cxx:1437
TileLaserObject::nbPmts
@ nbPmts
Definition: TileLaserObject.h:45
TileAANtuple::m_tileMuRcvRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_tileMuRcvRawChannelContainerKey
Definition: TileAANtuple.h:367
h
TileAANtuple::m_tileMuRcvDigitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_tileMuRcvDigitsContainerKey
Definition: TileAANtuple.h:368
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
TileAANtuple::m_tdctimeout
bool m_tdctimeout
Definition: TileAANtuple.h:341
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
TileRawDataContainer::get_unit
UNIT get_unit() const
Definition: TileRawDataContainer.h:60
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileAANtuple::m_trigType
int m_trigType
trigger type (1=Phys, 2=Laser, 4=Ped, 8=CIS)
Definition: TileAANtuple.h:197
CLEAR
#define CLEAR(array)
Definition: TileAANtuple.cxx:66
CaloDetDescrElement::z
float z() const
cell z
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:367
TileLaserObject::getPMSigmaPedestal
double getPMSigmaPedestal(const unsigned int j, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:237
TileCablingService::channel2hole
static int channel2hole(int ros, int channel)
Definition: TileCablingService.cxx:1946
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
NAME2
#define NAME2(s1, s2)
Definition: TileAANtuple.cxx:93
TileLaserObject::getDiodePedestal
double getDiodePedestal(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:109
TileAANtuple::storeLaser
StatusCode storeLaser(const EventContext &ctx)
Definition: TileAANtuple.cxx:492
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
TileAANtuple::m_sumEz_yy
float m_sumEz_yy[N_DRAWERS]
Sum Ez calcualted inside DSP.
Definition: TileAANtuple.h:421
TileDetDescrManager::calo_element_const_iterator
calo_element_vec::const_iterator calo_element_const_iterator
Definition: TileDetDescrManager.h:56
CaloDetDescrElement::eta
float eta() const
cell eta
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:344
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
TileAANtuple::m_nBadDr
int m_nBadDr
Definition: TileAANtuple.h:343
CaloDetDescrElement::phi
float phi() const
cell phi
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:346
TileAANtuple::m_las_Temperature
float m_las_Temperature
Definition: TileAANtuple.h:215
TileAANtuple::m_las_ReqAmp
float m_las_ReqAmp
Definition: TileAANtuple.h:213
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
TileAANtuple::digiChannel2PMT
int digiChannel2PMT(int fragType, int chan)
Definition: TileAANtuple.h:161
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
TileAANtuple::m_l1Type
int m_l1Type[N_RODS]
Level1 Type from ROD header.
Definition: TileAANtuple.h:201
N_TMDBCHANS
#define N_TMDBCHANS
Definition: TileAANtuple.h:81
TileAANtuple::CheckDMUFormat
short CheckDMUFormat(uint32_t header)
bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0
Definition: TileAANtuple.h:167
TileAANtuple::TRIGGER_addBranch
void TRIGGER_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add TRIGGER variables t...
Definition: TileAANtuple.cxx:1636
TileAANtuple::m_l1ID
int m_l1ID[N_RODS]
Level1 ID from ROD header.
Definition: TileAANtuple.h:200
TileLaserObject::getSigmaAlpha
double getSigmaAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:152
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
TileAANtuple::m_qieRawChannelContainerKey
SG::ReadHandleKey< TileRawChannelContainer > m_qieRawChannelContainerKey
Definition: TileAANtuple.h:361
TileLaserObject::getDaqType
int getDaqType() const
Definition: TileLaserObject.h:325
TileAANtuple::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileAANtuple.h:403
TileAANtuple::m_DQstatusKey
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
Definition: TileAANtuple.h:444
TileAANtuple::CheckDMUParity
short CheckDMUParity(uint32_t header)
Parity of the DMU header should be odd.
Definition: TileAANtuple.h:177
TileAANtuple::m_rchUnit
TileRawChannelUnit::UNIT m_rchUnit
Unit for TileRawChannels (ADC, pCb, MeV)
Definition: TileAANtuple.h:384
TileAANtuple::m_useDspUnits
bool m_useDspUnits
true if energy should be converted to units used in DSP
Definition: TileAANtuple.h:374
python.PyAthena.obj
obj
Definition: PyAthena.py:132
sample_ind
#define sample_ind(r, m, c, i)
Definition: TileAANtuple.cxx:102
CREATE
#define CREATE(__TYPE)
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
TileContainer
Definition: TileContainer.h:38
TileAANtuple::TMDB_addBranch
void TMDB_addBranch(void)
Definition: TileAANtuple.cxx:2184
TileCalibUtils::getDrawerIdxFromFragId
static unsigned int getDrawerIdxFromFragId(unsigned int fragId)
Returns a drawer hash from fragId This function assumes drawer context (i.e.
Definition: TileCalibUtils.cxx:71
TileAANtuple::CISPAR_addBranch
void CISPAR_addBranch(void)
//////////////////////////////////////////////////////////////////////////// /Add Tree CISPAR variabl...
Definition: TileAANtuple.cxx:1683
TileAANtuple::m_tileDCS
ToolHandle< ITileDCSTool > m_tileDCS
Definition: TileAANtuple.h:413
TileAANtuple::m_nBadTotal
int m_nBadTotal
Definition: TileAANtuple.h:347
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileLaserObject
Definition: TileLaserObject.h:33
TileAANtuple::DCS_addBranch
void DCS_addBranch(void)
Definition: TileAANtuple.cxx:2218
TileAANtuple::m_nSamples
int m_nSamples
number of samples
Definition: TileAANtuple.h:349
TileAANtuple::m_fltDigitsContainerKey
SG::ReadHandleKey< TileDigitsContainer > m_fltDigitsContainerKey
Definition: TileAANtuple.h:355
TileAANtuple::m_robSvc
ServiceHandle< IROBDataProviderSvc > m_robSvc
Definition: TileAANtuple.h:438
TileBchStatus::isBad
bool isBad() const
Definition: TileBchStatus.h:145
TileAANtuple::m_qdctimeout
bool m_qdctimeout
Definition: TileAANtuple.h:340
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
TileRawChannelUnit::ADCcounts
@ ADCcounts
Definition: TileRawChannelUnit.h:17
python.trfValidateRootFile.rc
rc
Definition: trfValidateRootFile.py:355
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
TileAANtuple::m_evt
int m_evt
event number in a run
Definition: TileAANtuple.h:193
fitman.k
k
Definition: fitman.py:528
TileLaserObject::getSigma
double getSigma(int chan, int gain, int type) const
Definition: TileLaserObject.cxx:49
TileRawChannelUnit::OnlineMegaElectronVolts
@ OnlineMegaElectronVolts
Definition: TileRawChannelUnit.h:24
TileLaserObject::getPedestalAlpha
double getPedestalAlpha(const unsigned int i, const unsigned int gain=0) const
Definition: TileLaserObject.cxx:166
TileAANtuple::storeDigits
StatusCode storeDigits(const EventContext &ctx, const SG::ReadHandleKey< TileDigitsContainer > &containerKey, short *sample, short gain[N_ROS2][N_MODULES][N_CHANS], bool fillAll)
/ Fill Ntuple with info from TileDigits / Return true if the collection is empty
Definition: TileAANtuple.cxx:1044
TileAANtuple::m_arrays
std::unique_ptr< Arrays > m_arrays
Definition: TileAANtuple.h:338
PlotCalibFromCool.br
br
Definition: PlotCalibFromCool.py:355
ServiceHandle< ICondSvc >
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Jan 9 2025 21:46:23 for ATLAS Offline Software by   doxygen 1.8.18