ATLAS Offline Software
CaloMBTSRetriever.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "CaloMBTSRetriever.h"
6 
7 #include "CLHEP/Units/SystemOfUnits.h"
8 
9 #include "EventContainers/SelectAllObject.h"
10 
11 #include "CaloDetDescr/CaloDetDescrElement.h"
12 #include "TileEvent/TileCell.h"
13 #include "TileEvent/TileCellContainer.h"
14 #include "Identifier/HWIdentifier.h"
15 #include "CaloIdentifier/TileID.h"
16 #include "TileIdentifier/TileHWID.h"
17 #include "TileIdentifier/TileTBID.h"
18 #include "TileConditions/TileInfo.h"
19 #include "TileConditions/TileCablingService.h"
20 #include "TileCalibBlobObjs/TileCalibUtils.h"
21 
22 namespace JiveXML {
23 
30  CaloMBTSRetriever::CaloMBTSRetriever(const std::string& type,const std::string& name,const IInterface* parent):
31  AthAlgTool(type,name,parent),
32  m_tileTBID(nullptr)
33  {
34  //Only declare the interface
35  declareInterface<IDataRetriever>(this);
36 
37  declareProperty("MBTSThreshold", m_mbtsThreshold = 0.05);
38  declareProperty("RetrieveMBTS" , m_mbts = true);
39  declareProperty("DoMBTSDigits", m_mbtsdigit=false);
40  declareProperty("DoMBTSCellDetails", m_mbtsCellDetails = false);
41 
42  // TileDigitsContainer names: {"TileDigitsCnt","TileDigitsFlt"};
43  declareProperty("TileDigitsContainer" ,m_sgKeyTileDigits = "",
44  "Input collection to retrieve Tile digits, used when doTileDigit is True");
45 
46  // TileRawChannelContainer names: {"TileRawChannelOpt2","TileRawChannelOpt","TileRawChannelFixed",
47  // "TileRawChannelFitCool","TileRawChannelFit",
48  // "TileRawChannelCnt","TileRawChannelFlt"};
49  declareProperty("TileRawChannelContainer" ,m_sgKeyTileRawChannel = "",
50  "Input collection to retrieve Tile raw channels, used when DoMBTSCellDetails is True.");
51  }
52 
57  StatusCode CaloMBTSRetriever::initialize() {
58 
59  ATH_MSG_DEBUG( "Initialising Tool" );
60 
61  ATH_CHECK(m_sgKeyMBTS.initialize());
62 
63  //=== get TileCondToolTiming
64  ATH_CHECK( m_tileToolTiming.retrieve() );
65 
66  //=== get TileCondToolEmscale
67  ATH_CHECK( m_tileToolEmscale.retrieve() );
68 
69  ATH_CHECK( m_sgKeyTileDigits.initialize(m_mbtsdigit) );
70 
71  ATH_CHECK( m_sgKeyTileRawChannel.initialize(m_mbtsCellDetails) );
72 
73  return StatusCode::SUCCESS;
74  }
75 
79  StatusCode CaloMBTSRetriever::retrieve(ToolHandle<IFormatTool> &FormatTool) {
80 
81  ATH_MSG_DEBUG( "in retrieve()" );
82 
83  SG::ReadHandle<TileCellContainer> cellContainerMBTS(m_sgKeyMBTS);
84  if (!cellContainerMBTS.isValid()){
85  ATH_MSG_WARNING( "Could not retrieve MBTS Cells " );
86  }
87  else{
88  if (m_mbts) {
89  DataMap data = getMBTSData(&(*cellContainerMBTS));
90  ATH_CHECK( FormatTool->AddToEvent(dataTypeName(), m_sgKeyMBTS.key(), &data) );
91  ATH_MSG_DEBUG( "MBTS retrieved" );
92  }
93  }
94 
95  //MBTS cells retrieved okay
96  return StatusCode::SUCCESS;
97  }
98 
99 
104  const DataMap CaloMBTSRetriever::getMBTSData(const TileCellContainer* tileMBTSCellContainer) {
105 
106  ATH_MSG_DEBUG( "getMBTSData()" );
107 
108  DataMap DataMap;
109 
110  DataVect energy; energy.reserve(tileMBTSCellContainer->size());
111  DataVect label; label.reserve(tileMBTSCellContainer->size());
112  DataVect phi; phi.reserve(tileMBTSCellContainer->size());
113  DataVect eta; eta.reserve(tileMBTSCellContainer->size());
114  DataVect sampling; sampling.reserve(tileMBTSCellContainer->size());
115  DataVect timeVec; timeVec.reserve(tileMBTSCellContainer->size());
116  DataVect quality; quality.reserve(tileMBTSCellContainer->size());
117  DataVect type; type.reserve(tileMBTSCellContainer->size());
118  DataVect channel; channel.reserve(tileMBTSCellContainer->size());
119  DataVect module; module.reserve(tileMBTSCellContainer->size());
120  DataVect cellPedestal; cellPedestal.reserve(tileMBTSCellContainer->size());
121  DataVect cellRawAmplitude; cellRawAmplitude.reserve(tileMBTSCellContainer->size());
122  DataVect cellRawTime; cellRawTime.reserve(tileMBTSCellContainer->size());
123  DataVect adcCounts; adcCounts.reserve(tileMBTSCellContainer->size() * 10);
124 
125  std::string adcCountsStr="adcCounts multiple=\"0\"";
126  const TileHWID* tileHWID = nullptr;
127  const TileInfo* tileInfo = nullptr;
128  const TileCablingService* cabling=nullptr;
129  TileRawChannelUnit::UNIT RChUnit = TileRawChannelUnit::ADCcounts;
130  cabling = TileCablingService::getInstance();
131  bool offlineRch = false;
132 
133  if ( detStore()->retrieve(m_tileTBID).isFailure() ) {
134  ATH_MSG_ERROR( "in getMBTSData(), Could not retrieve m_tileTBID" );
135  }
136 
137  if ( detStore()->retrieve(tileHWID).isFailure() ) {
138  ATH_MSG_ERROR( "in getMBTSData(), Could not retrieve TileHWID" );
139  }
140 
141  if ( detStore()->retrieve(tileInfo, "TileInfo").isFailure() ) {
142  ATH_MSG_ERROR( "in getMBTSData(), Could not retrieve TileInfo" );
143  }
144 
145  SG::ReadHandle<TileRawChannelContainer> RawChannelCnt;
146  if (m_mbtsCellDetails) {
147  RawChannelCnt = SG::makeHandle(m_sgKeyTileRawChannel);
148  if (!RawChannelCnt.isValid()){
149  ATH_MSG_WARNING( "Could not retrieve TileRawChannel " );
150  }
151  else{
152  RChUnit = RawChannelCnt->get_unit();
153  offlineRch = (RChUnit<TileRawChannelUnit::OnlineADCcounts &&
154  RawChannelCnt->get_type() != TileFragHash::OptFilterDsp);
155  }
156  }
157 
158  SG::ReadHandle<TileDigitsContainer> tileDigits;
159  if (m_mbtsdigit) {
160  tileDigits = SG::makeHandle(m_sgKeyTileDigits);
161  if (!tileDigits.isValid()){
162  ATH_MSG_WARNING( "Could not retrieve TileDigits " );
163  }
164  }
165 
166  // from: TileCalorimeter/TileRec/src/TileCellToNtuple.cxx
167 
168  std::string MBTS_ID;
169  int nchan =0;
170  int nTileSamples=0;
171  const int max_chan=5216;
172  double energyMeV = 0.;
173  double phiMBTS = 0.;
174  double amplitude = 0.;
175  unsigned long int cellid;
176  std::map<unsigned long int,double> theMbtspedestal;
177  std::map<unsigned long int,double> theMbtsrawamp;
178  std::map<unsigned long int,double> theMbtsrawtime;
179  std::map<unsigned long int,std::vector<float> > theMbtsdigit;
180  std::string myCellRawTimeStr = "0.";
181 
182  //Loop over TileRawChannel to get Pedestal and raw amplitude and time
183 
184  if (m_mbtsCellDetails && RawChannelCnt.isValid()) {
185  if (offlineRch) {
186 
187  for (const auto rawChannel : *RawChannelCnt) {
188 
189  for (const auto cell : *rawChannel) {
190 
191  Identifier pmt_id = cell->pmt_ID();
192  if (!m_tileTBID->is_tiletb(pmt_id)) continue;
193 
194  Identifier id = cell->cell_ID();
195  cellid = id.get_identifier32().get_compact();
196  HWIdentifier hwid=cell->adc_HWID();
197  int adc = tileHWID->adc(hwid);
198  int channel = tileHWID->channel(hwid);
199  int drawer = tileHWID->drawer(hwid);
200  int ros = tileHWID->ros(hwid);
201  int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
202 
203  amplitude = cell->amplitude();
204  //Change amplitude units to ADC counts
205  if (TileRawChannelUnit::ADCcounts < RChUnit && RChUnit < TileRawChannelUnit::OnlineADCcounts) {
206  amplitude /= m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0, TileRawChannelUnit::ADCcounts, RChUnit);
207  } else if (RChUnit > TileRawChannelUnit::OnlineADCcounts) {
208  amplitude = m_tileToolEmscale->undoOnlCalib(drawerIdx, channel, adc, amplitude, RChUnit);
209  }
210 
211  theMbtspedestal.insert(std::make_pair( cellid, cell->pedestal() ) );
212  theMbtsrawamp.insert(std::make_pair( cellid, amplitude ));
213  theMbtsrawtime.insert(std::make_pair( cellid, cell->time(cell->uncorrTime()) ));
214  break;
215 
216  }
217  }
218  }
219  }
220 
221  //Loop over TileDigits to retrieve MBTS digits
222 
223  if (m_mbtsdigit && tileDigits.isValid()) {
224 
225  //----- get tile digits--------------------------
226 
227  // tile digits loop
228  for (const auto digitChannel : *tileDigits) {
229 
230  for (const auto cell : *digitChannel) {
231 
232  Identifier pmt_id = cell->pmt_ID();
233  if (!m_tileTBID->is_tiletb(pmt_id)) continue;
234 
235  Identifier id = cell->cell_ID();
236  cellid = id.get_identifier32().get_compact();
237 
238  nTileSamples = cell->NtimeSamples();
239  std::vector<float> tileSamples = cell->samples();
240  theMbtsdigit.insert(std::make_pair( cellid, tileSamples));
241  break;
242 
243  }
244  }//for TileDigitContainer loop
245  } //if (m_mbtsdigit)
246 
247  //Loop Over TileCellContainer to retrieve MBTSCell information
248 
249  for (const auto cell : *tileMBTSCellContainer) {
250 
251  int qual = cell->quality();
252  if (cell->badcell()) qual = -qual;
253 
254  timeVec.push_back(DataType( cell->time() ));
255  quality.push_back(DataType( qual ));
256 
257  if ( cell->energy() >= m_mbtsThreshold ) {
258  energyMeV = cell->energy(); // roughly correct: energy unit is pC, which is 95% MeV
259  }else{
260  energyMeV = 0.;
261  }
262  energy.push_back(DataType( energyMeV )); // write in MeV
263 
264  Identifier id=cell->ID();
265 
266  //TileCell/type is "side" +/- 1
267  //TileCell/module is "phi" 0-7
268  //TileCell/channel is "eta" 0-1 zero is closer to beam pipe
269 
270  type.push_back(DataType( m_tileTBID->type(id) ));
271  channel.push_back(DataType( m_tileTBID->channel(id) ));
272  module.push_back(DataType( m_tileTBID->module(id) ));
273 
274  MBTS_ID = "type_" + DataType( m_tileTBID->type(id) ).toString() + "_ch_" +
275  DataType( m_tileTBID->channel(id) ).toString() + "_mod_" +
276  DataType( m_tileTBID->module(id) ).toString();
277 
278  label.push_back(DataType( MBTS_ID ));
279 
280  eta.push_back(DataType( 5.0*m_tileTBID->type(id) ));
281 
282  phiMBTS = (M_PI/8)+(2*M_PI/8)*int(m_tileTBID->module(id));
283  phi.push_back(DataType( phiMBTS ));
284  sampling.push_back(DataType( m_tileTBID->channel(id) ));
285 
286  if (m_mbtsCellDetails && RawChannelCnt.isValid()) {
287 
288  cellPedestal.push_back(DataType( theMbtspedestal[id.get_identifier32().get_compact()] ));
289  cellRawAmplitude.push_back(DataType( theMbtsrawamp[id.get_identifier32().get_compact()] ));
290  myCellRawTimeStr = DataType(theMbtsrawtime[id.get_identifier32().get_compact()]).toString();
291 
292  if ( myCellRawTimeStr.find("n") == 1 ) myCellRawTimeStr="0.";
293  cellRawTime.push_back( myCellRawTimeStr );
294 
295  // this can rarely be '-nan', but checking this each time may make code slow ?
296  }
297  else { // don't have TileRawChannel container (for DPF input)
298 
299  float maxTime = (tileInfo->NdigitSamples()/2) * 25;
300  int gain = cell->gain();
301 
302  if (gain<0 || gain>1) { //invalid gain - channel missing
303  cellRawAmplitude.push_back(DataType(0));
304  cellRawTime.push_back(DataType(0));
305  cellPedestal.push_back(DataType(0)); //There is no pedestal in DPD .
306  }
307  else {
308 
309  HWIdentifier hwid = tileHWID->adc_id(cabling->s2h_channel_id(id),gain);
310  int adc = tileHWID->adc(hwid);
311  int channel = tileHWID->channel(hwid);
312  int drawer = tileHWID->drawer(hwid);
313  int ros = tileHWID->ros(hwid);
314  int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
315  float scale = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0,
316  TileRawChannelUnit::ADCcounts, TileRawChannelUnit::MegaElectronVolts);
317  float amp;
318 
319  if ( cell->energy() >= m_mbtsThreshold ) amp = cell->energy()/scale;
320  else amp = 0.0;
321  float time = cell->time();
322 
323  if ((qual != 0 || amp != 0.0) && (fabs(time) < maxTime && time != 0.0)) {
324  time += m_tileToolTiming->getSignalPhase(drawerIdx, channel, adc);
325  }
326 
327  cellRawAmplitude.push_back(DataType(amp));
328  cellRawTime.push_back(DataType(time));
329  cellPedestal.push_back(DataType(0)); //There is no pedestal in DPD . This line is temporary.
330  }
331  }
332 
333 
334  if (m_mbtsdigit && tileDigits.isValid()) {
335 
336  if ( !theMbtsdigit[id.get_identifier32().get_compact()].empty() ) {
337  for (int i=0; i<nTileSamples; i++) {
338  adcCountsStr="adcCounts multiple=\""+DataType(nTileSamples).toString()+"\"";
339  adcCounts.push_back(DataType( int(theMbtsdigit[id.get_identifier32().get_compact()][i]) ));
340  }
341  }
342  else {
343  for (int i=0; i<nTileSamples; i++) {
344  adcCountsStr="adcCounts multiple=\""+DataType(nTileSamples).toString()+"\"";
345  adcCounts.push_back(DataType(0));
346  }
347  }
348  }
349 
350 
351  ATH_MSG_DEBUG( "MBTS no: " << nchan << ", type_chan_mod: " << MBTS_ID
352  << ", energy MeV pC: " << energyMeV );
353 
354  nchan++;
355 
356  if (nchan >= max_chan) break;
357 
358  }//TileCell Loop
359 
360  if (!theMbtspedestal.empty()) theMbtspedestal.clear();
361  if (!theMbtsrawamp.empty() ) theMbtsrawamp.clear();
362  if (!theMbtsrawtime.empty()) theMbtsrawtime.clear();
363 
364  // write values into DataMap
365  DataMap["energy"] = energy;
366  DataMap["label"] = label;
367  DataMap["phi"] = phi;
368  DataMap["eta"] = eta;
369  DataMap["sampling"] = sampling;
370  DataMap["time"] = timeVec;
371  DataMap["quality"] = quality;
372  DataMap["type"] = type;
373  DataMap["channel"] = channel;
374  DataMap["module"] = module;
375  DataMap["cellPedestal"] = cellPedestal;
376  DataMap["cellRawAmplitude"] = cellRawAmplitude;
377  DataMap["cellRawTime"] = cellRawTime;
378  DataMap[adcCountsStr] = adcCounts;
379 
380  //Be verbose
381  ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << phi.size() << " entries" );
382 
383  //All collections retrieved okay
384  return DataMap;
385 
386  } // getMBTSData
387 
388  //--------------------------------------------------------------------------
389 
390 } // JiveXML namespace
JiveXML::CaloMBTSRetriever::m_tileTBID
const TileTBID * m_tileTBID
Definition: CaloMBTSRetriever.h:71
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
JiveXML::CaloMBTSRetriever::initialize
StatusCode initialize()
Default AthAlgTool methods.
Definition: CaloMBTSRetriever.cxx:57
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
TileTBID::is_tiletb
bool is_tiletb(const Identifier &id) const
Test ID if it is TileTBID.
Definition: TileTBID.cxx:86
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TileInfo::NdigitSamples
int NdigitSamples() const
Returns the number of sammples (digits) per event.
Definition: TileInfo.h:75
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
JiveXML::CaloMBTSRetriever::m_sgKeyTileDigits
SG::ReadHandleKey< TileDigitsContainer > m_sgKeyTileDigits
Definition: CaloMBTSRetriever.h:75
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
PlotCalibFromCool.label
label
Definition: PlotCalibFromCool.py:78
JiveXML::DataVect
std::vector< DataType > DataVect
Defines a map with a key and a vector of DataType objects e.g.
Definition: DataType.h:58
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
DataType
OFFLINE_FRAGMENTS_NAMESPACE::PointerType DataType
Definition: RoIBResultByteStreamTool.cxx:25
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
M_PI
#define M_PI
Definition: ActiveFraction.h:11
PlotCalibFromCool.nchan
nchan
Definition: PlotCalibFromCool.py:564
JiveXML::CaloMBTSRetriever::m_mbts
bool m_mbts
Definition: CaloMBTSRetriever.h:78
TileInfo.h
TileCalibUtils.h
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
TileInfo
Definition: TileInfo.h:49
TileTBID::type
int type(const Identifier &id) const
extract type field from TileTB identifier
Definition: Calorimeter/CaloIdentifier/CaloIdentifier/TileTBID.h:146
JiveXML::DataMap
std::map< std::string, DataVect > DataMap
Definition: DataType.h:59
HWIdentifier
Definition: HWIdentifier.h:13
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
TileFragHash::OptFilterDsp
@ OptFilterDsp
Definition: TileFragHash.h:34
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileTBID::module
int module(const Identifier &id) const
extract module field from TileTB identifier
Definition: Calorimeter/CaloIdentifier/CaloIdentifier/TileTBID.h:150
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
TileID.h
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
python.PyAthena.module
module
Definition: PyAthena.py:134
TileHWID
Helper class for TileCal online (hardware) identifiers.
Definition: TileHWID.h:49
JiveXML::CaloMBTSRetriever::m_mbtsdigit
bool m_mbtsdigit
Definition: CaloMBTSRetriever.h:79
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileHWID.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
TileCablingService.h
lumiFormat.i
int i
Definition: lumiFormat.py:92
JiveXML::CaloMBTSRetriever::dataTypeName
virtual std::string dataTypeName() const
Return the name of the data type.
Definition: CaloMBTSRetriever.h:59
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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
TileCell.h
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
test_pyathena.parent
parent
Definition: test_pyathena.py:15
JiveXML::CaloMBTSRetriever::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: CaloMBTSRetriever.h:68
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
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
TileCablingService
Definition: TileCablingService.h:23
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
TileTBID::channel
int channel(const Identifier &id) const
extract channel field from TileTB identifier
Definition: Calorimeter/CaloIdentifier/CaloIdentifier/TileTBID.h:154
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
JiveXML
This header is shared inbetween the C-style server thread and the C++ Athena ServerSvc.
Definition: BadLArRetriever.cxx:21
JiveXML::CaloMBTSRetriever::retrieve
virtual StatusCode retrieve(ToolHandle< IFormatTool > &FormatTool)
Retrieve all the data.
Definition: CaloMBTSRetriever.cxx:79
HWIdentifier.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
JiveXML::CaloMBTSRetriever::m_sgKeyMBTS
SG::ReadHandleKey< TileCellContainer > m_sgKeyMBTS
properties:
Definition: CaloMBTSRetriever.h:74
TileRawDataContainer::get_type
TYPE get_type() const
Definition: TileRawDataContainer.h:62
JiveXML::CaloMBTSRetriever::m_tileToolTiming
ToolHandle< TileCondToolTiming > m_tileToolTiming
Definition: CaloMBTSRetriever.h:65
TileHWID::adc_id
HWIdentifier adc_id(int ros, int drawer, int channel, int adc) const
adc HWIdentifer
Definition: TileHWID.cxx:228
JiveXML::CaloMBTSRetriever::m_sgKeyTileRawChannel
SG::ReadHandleKey< TileRawChannelContainer > m_sgKeyTileRawChannel
Definition: CaloMBTSRetriever.h:76
JiveXML::CaloMBTSRetriever::getMBTSData
const DataMap getMBTSData(const TileCellContainer *tileMBTSCellContainer)
Retrieve MBTS cell location and details.
Definition: CaloMBTSRetriever.cxx:104
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
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
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
max_chan
const int max_chan
Definition: TileCellIDCToNtuple.cxx:35
JiveXML::CaloMBTSRetriever::m_mbtsCellDetails
bool m_mbtsCellDetails
Definition: CaloMBTSRetriever.h:80
beamspotman.qual
qual
Definition: beamspotman.py:481
TileTBID.h
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
SelectAllObject.h
AthAlgTool
Definition: AthAlgTool.h:26
CaloMBTSRetriever.h
TileContainer
Definition: TileContainer.h:38
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TileRawChannelUnit::ADCcounts
@ ADCcounts
Definition: TileRawChannelUnit.h:17
TileCellContainer.h
JiveXML::CaloMBTSRetriever::CaloMBTSRetriever
CaloMBTSRetriever(const std::string &type, const std::string &name, const IInterface *parent)
Standard Constructor.
Definition: CaloMBTSRetriever.cxx:30
JiveXML::CaloMBTSRetriever::m_mbtsThreshold
double m_mbtsThreshold
Definition: CaloMBTSRetriever.h:77
Generated on Sun Jun 30 2024 21:12:00 for ATLAS Offline Software by   doxygen 1.8.18