ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
JiveXML::CaloTileRetriever Class Reference

Retrieves all Tile Calo Cell objects. More...

#include <CaloTileRetriever.h>

Inheritance diagram for JiveXML::CaloTileRetriever:
Collaboration diagram for JiveXML::CaloTileRetriever:

Public Member Functions

 CaloTileRetriever (const std::string &type, const std::string &name, const IInterface *parent)
 Standard Constructor. More...
 
virtual StatusCode retrieve (ToolHandle< IFormatTool > &FormatTool)
 Retrieve all the data. More...
 
const DataMap getCaloTileData (const CaloCellContainer *cellContainer)
 Retrieve Tile cell location and details. More...
 
virtual std::string dataTypeName () const
 Return the name of the data type. More...
 
StatusCode initialize ()
 Default AthAlgTool methods. 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 sysInitialize () override
 Perform system initialization for an algorithm. 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
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 Return the interface identifier. More...
 

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

void calcTILELayerSub (Identifier &)
 
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

ToolHandle< TileCondToolTiming > m_tileToolTiming
 
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
 
ToolHandle< ITileBadChanTool > m_tileBadChanTool
 
const CaloCell_ID * m_calocell_id
 
SG::ReadHandleKey< CaloCellContainer > m_sgKey {this, "StoreGateKey", "AllCalo", "Name of the CaloCellContainer"}
 
SG::ReadHandleKey< TileDigitsContainer > m_sgKeyTileDigits {this, "TileDigitsContainerKey", "", "Name of the TileDigitsContainer"}
 
SG::ReadHandleKey< TileRawChannelContainer > m_sgKeyTileRawChannel {this, "TileRawChannelContainerKey", "", "Name of the TileRawChannelContainer"}
 
double m_cellThreshold
 
int m_cellEnergyPrec
 
int m_cellTimePrec
 
bool m_tile
 
bool m_doTileDigit
 
bool m_doTileCellDetails
 
bool m_doBadTile
 
DataVect m_sub
 
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

Retrieves all Tile Calo Cell objects.

Definition at line 48 of file CaloTileRetriever.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CaloTileRetriever()

JiveXML::CaloTileRetriever::CaloTileRetriever ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Standard Constructor.

This is the standard AthAlgTool constructor.

Parameters
typeAlgTool type name
nameAlgTool instance name
parentAlgTools parent owning this tool

Definition at line 37 of file CaloTileRetriever.cxx.

37  :
38  AthAlgTool(type,name,parent),
39  m_calocell_id(nullptr)
40  {
41  //Only declare the interface
42  declareInterface<IDataRetriever>(this);
43 
44  declareProperty("CellThreshold", m_cellThreshold = 50.);
45  declareProperty("RetrieveTILE" , m_tile = true);
46  declareProperty("DoTileDigit", m_doTileDigit = false);
47  declareProperty("DoBadTile", m_doBadTile = false);
48  declareProperty("DoTileCellDetails", m_doTileCellDetails = false);
49  declareProperty("CellEnergyPrec", m_cellEnergyPrec = 3);
50  declareProperty("CellTimePrec", m_cellTimePrec = 3);
51 
52  // TileDigitsContainer names: {"TileDigitsCnt","TileDigitsFlt"};
53  declareProperty("TileDigitsContainer" ,m_sgKeyTileDigits = "",
54  "Input collection to retrieve Tile digits, used when doTileDigit is True");
55 
56  // TileRawChannelContainer names: {"TileRawChannelOpt2","TileRawChannelOpt","TileRawChannelFixed",
57  // "TileRawChannelFitCool","TileRawChannelFit",
58  // "TileRawChannelCnt","TileRawChannelFlt"};
59  declareProperty("TileRawChannelContainer" ,m_sgKeyTileRawChannel = "",
60  "Input collection to retrieve Tile raw channels, used when doTileCellDetails is True.");
61  }

Member Function Documentation

◆ calcTILELayerSub()

void JiveXML::CaloTileRetriever::calcTILELayerSub ( Identifier &  cellid)
private

Definition at line 553 of file CaloTileRetriever.cxx.

554  {
555  if (m_calocell_id->is_tile_barrel(cellid))
556  {
557  if (m_calocell_id->is_tile_negative(cellid))
558  m_sub.push_back(DataType(2));
559  else
560  m_sub.push_back(DataType(3));
561  }
562  else if (m_calocell_id->is_tile_extbarrel(cellid))
563  {
564  if (m_calocell_id->is_tile_negative(cellid))
565  m_sub.push_back(DataType(0));
566  else
567  m_sub.push_back(DataType(5));
568  }
569  //else in ITC or scint
570  else
571  {
572  if (m_calocell_id->is_tile_negative(cellid))
573  m_sub.push_back(DataType(1));
574  else
575  m_sub.push_back(DataType(4));
576  }
577  }

◆ dataTypeName()

virtual std::string JiveXML::CaloTileRetriever::dataTypeName ( ) const
inlinevirtual

Return the name of the data type.

Implements JiveXML::IDataRetriever.

Definition at line 61 of file CaloTileRetriever.h.

61 { return "TileDigit"; };

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ getCaloTileData()

const DataMap JiveXML::CaloTileRetriever::getCaloTileData ( const CaloCellContainer *  cellContainer)

Retrieve Tile cell location and details.

Parameters
FormatToolthe tool that will create formated output from the DataMap

< Unit for TileRawChannels (ADC, pCb, etc.)

Definition at line 118 of file CaloTileRetriever.cxx.

118  {
119 
120  ATH_MSG_DEBUG( "getTileData()" );
121  char rndStr[30];
122  DataMap DataMap;
123 
124  DataVect phi; phi.reserve(cellContainer->size());
125  DataVect eta; eta.reserve(cellContainer->size());
126  DataVect idVec; idVec.reserve(cellContainer->size());
127  DataVect energyVec; energyVec.reserve(cellContainer->size());
128  DataVect adcCounts1Vec; adcCounts1Vec.reserve(cellContainer->size() * 10);
129  DataVect adcCounts2Vec; adcCounts2Vec.reserve(cellContainer->size() * 10);
130  DataVect BadCell; BadCell.reserve(cellContainer->size());
131 
132  DataVect pmt1Energy; pmt1Energy.reserve(cellContainer->size());
133  DataVect pmt1Time; pmt1Time.reserve(cellContainer->size());
134  DataVect pmt1Chi2; pmt1Chi2.reserve(cellContainer->size());
135  DataVect pmt1Gain; pmt1Gain.reserve(cellContainer->size());
136  DataVect pmt2Energy; pmt2Energy.reserve(cellContainer->size());
137  DataVect pmt2Time; pmt2Time.reserve(cellContainer->size());
138  DataVect pmt2Chi2; pmt2Chi2.reserve(cellContainer->size());
139  DataVect pmt2Gain; pmt2Gain.reserve(cellContainer->size());
140 
141  DataVect pmt1RawAmplitude; pmt1RawAmplitude.reserve(cellContainer->size());
142  DataVect pmt1RawTime; pmt1RawTime.reserve(cellContainer->size());
143  DataVect pmt1Pedestal; pmt1Pedestal.reserve(cellContainer->size());
144  DataVect pmt1Number; pmt1Number.reserve(cellContainer->size());
145  DataVect pmt1ADCStatus; pmt1ADCStatus.reserve(cellContainer->size());
146  DataVect pmt2RawAmplitude; pmt2RawAmplitude.reserve(cellContainer->size());
147  DataVect pmt2RawTime; pmt2RawTime.reserve(cellContainer->size());
148  DataVect pmt2Pedestal; pmt2Pedestal.reserve(cellContainer->size());
149  DataVect pmt2Number; pmt2Number.reserve(cellContainer->size());
150  DataVect pmt2ADCStatus; pmt2ADCStatus.reserve(cellContainer->size());
151 
152 // m_sub; m_sub.reserve(cellContainer->size());
153  m_sub.clear();
154 
155  std::string adcCounts1Str = "adcCounts1 multiple=\"0\"";
156  std::string adcCounts2Str = "adcCounts2 multiple=\"0\"";
157 
158  const TileID* tileID = nullptr;
159  const TileHWID* tileHWID = nullptr;
160  const TileInfo* tileInfo = nullptr;
161  const TileCablingService* cabling=nullptr;
162  TileRawChannelUnit::UNIT RChUnit = TileRawChannelUnit::ADCcounts;
163  cabling = TileCablingService::getInstance();
164  double energyGeV;
165  double amplitude = 0.;
166  const int vsize = cellContainer->size(); //5184;
167  int Index,pmtInd, cellInd, nTileSamples=0;
168  std::vector<double> pmt1ped(vsize,0.0);
169  std::vector<double> pmt2ped(vsize,0.0);
170  std::vector<double> pmt1rawamp(vsize,0.0);
171  std::vector<double> pmt2rawamp(vsize,0.0);
172  std::vector<double> pmt1rawtime(vsize,0.0);
173  std::vector<double> pmt2rawtime(vsize,0.0);
174  std::vector<int> pmt1number(vsize,0);
175  std::vector<int> pmt2number(vsize,0);
176  std::vector<unsigned long int> pmt1status(vsize,0);
177  std::vector<unsigned long int> pmt2status(vsize,0);
178  std::map<int,std::vector<float> > pmt1digit;
179  std::map<int,std::vector<float> > pmt2digit;
180  bool offlineRch = false;
181 
182  //===== retrieving everything which is needed for Tile
183 
184  if (detStore()->retrieve(tileID).isFailure()) {
185  ATH_MSG_ERROR( "in getCaloTileData(), Could not retrieve TileID" );
186 
187  }
188 
189  if (detStore()->retrieve(tileHWID).isFailure()) {
190  ATH_MSG_ERROR( "in getCaloTileData(), Could not retrieve TileHWID" );
191  }
192 
193  if (detStore()->retrieve(tileInfo, "TileInfo").isFailure()) {
194  ATH_MSG_ERROR( "in getCaloTileData(), Could not retrieve TileInfo" );
195  }
196 
197  SG::ReadHandle<TileDigitsContainer> tileDigits;
198  if (m_doTileDigit) {
199  tileDigits = SG::makeHandle(m_sgKeyTileDigits);
200  if (!tileDigits.isValid()){
201  ATH_MSG_WARNING( "Could not retrieve TileDigits " );
202  }
203  }
204 
205  SG::ReadHandle<TileRawChannelContainer> RawChannelCnt;
206  if (m_doTileCellDetails) {
207  RawChannelCnt = SG::makeHandle(m_sgKeyTileRawChannel);
208  if (!RawChannelCnt.isValid()){
209  ATH_MSG_WARNING( "Could not retrieve TileRawChannel " );
210  }
211  else {
212  RChUnit = RawChannelCnt->get_unit();
213  offlineRch = (RChUnit<TileRawChannelUnit::OnlineADCcounts &&
214  RawChannelCnt->get_type() != TileFragHash::OptFilterDsp);
215  }
216  }
217 
218 
219  // Loop Over TileRawChannelContainer to retrieve raw information. Keep the values in vectors
220 
221  if (m_doTileCellDetails && RawChannelCnt.isValid()) {
222  if (offlineRch) {
223 
224  for (const auto rawChannel : *RawChannelCnt) {
225 
226  for (const auto cell : *rawChannel) {
227 
228  /*Identifier cell_id =*/ cell->cell_ID_index(Index,pmtInd);
229  if (Index <= -1 ) continue; //disconnect channel index is -1 and MBTS is -2. They do not have an idhash
230  IdentifierHash cell_hash = m_calocell_id->calo_cell_hash( cell->cell_ID() );
231  cellInd = cellContainer->findIndex(cell_hash); //find Cell Index
232  if (cellInd < 0) continue;
233 
234  HWIdentifier hwid=cell->adc_HWID();
235  int adc = tileHWID->adc(hwid);
236  int channel = tileHWID->channel(hwid);
237  int drawer = tileHWID->drawer(hwid);
238  int ros = tileHWID->ros(hwid);
239  int PMT = abs( cabling->channel2hole(ros,channel) );
240  int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
241  uint32_t tileAdcStatus = m_tileBadChanTool->encodeStatus(m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc));
242 
243  amplitude = cell->amplitude();
244  //Change amplitude units to ADC counts
245  if (TileRawChannelUnit::ADCcounts < RChUnit && RChUnit < TileRawChannelUnit::OnlineADCcounts) {
246  amplitude /= m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0, TileRawChannelUnit::ADCcounts, RChUnit);
247  } else if (RChUnit > TileRawChannelUnit::OnlineADCcounts) {
248  // Should never get here due to offlineRch test above.
249  //amplitude = m_tileToolEmscale->undoOnlCalib(drawerIdx, channel, adc, amplitude, RChUnit);
250  std::abort();
251  }
252 
253  if ( pmtInd == 0 ) { // first PMT
254 
255  pmt1ped[cellInd] = cell->pedestal();
256  pmt1rawamp[cellInd] = amplitude;
257  pmt1rawtime[cellInd] = cell->uncorrTime();
258  pmt1number[cellInd] = PMT;
259  pmt1status[cellInd] = tileAdcStatus;
260  }
261  else { // second PMT
262 
263  pmt2ped[cellInd] = cell->pedestal();
264  pmt2rawamp[cellInd] = amplitude;
265  pmt2rawtime[cellInd] = cell->uncorrTime();
266  pmt2number[cellInd] = PMT;
267  pmt2status[cellInd] = tileAdcStatus;
268 
269  }
270  }
271  }//for TileRawChannelContainer loop
272  }
273  } // end of doTileCellDetails
274 
275 
276  //Loop over TileDigitsContainer to retrieve digits. Keep the digits values in a map
277 
278  if (m_doTileDigit && tileDigits.isValid()) {
279 
280  //----- get tile digits--------------------------
281 
282  // tile digits loop
283  for (const auto digitChannel : *tileDigits) {
284 
285  for (const auto cell : *digitChannel) {
286 
287  /*Identifier cell_id =*/ cell->cell_ID_index(Index,pmtInd);
288  if (Index <= -1 ) continue; //disconnect channel index is -1 and MBTS is -2. They do not have an idhash
289  IdentifierHash cell_hash = m_calocell_id->calo_cell_hash( cell->cell_ID() );
290  cellInd = cellContainer->findIndex(cell_hash); //find Cell Index
291  if (cellInd < 0) continue;
292  if ( (*cellContainer)[cellInd]->energy() < m_cellThreshold) continue;
293 
294  nTileSamples = cell->NtimeSamples();
295  std::vector<float> tileSamples = cell->samples();
296 
297  if (pmtInd == 0 ) { // first PMT
298  pmt1digit.insert(std::make_pair( cellInd, tileSamples ) );
299  }
300  else { // second PMT
301  pmt2digit.insert(std::make_pair( cellInd, tileSamples ) );
302  }
303 
304  }
305  }//for TileDigitContainer loop
306  } // end if doTileDigit
307 
308 
309  //Loop Over CaloCellContainer to retrieve TileCell information
310 
311  CaloCellContainer::const_iterator it1 = cellContainer->beginConstCalo(CaloCell_ID::TILE);
312  CaloCellContainer::const_iterator it2 = cellContainer->endConstCalo(CaloCell_ID::TILE);
313 
314  double energyAllTile = 0.;
315 
316  for (;it1!=it2;++it1) {
317 
318  if ((*it1)->badcell()) BadCell.push_back(1);
319  else if ((*it1)->energy()>= m_cellThreshold) BadCell.push_back(0);
320  else BadCell.push_back(-1);
321 
322  Identifier cellid = (*it1)->ID();
323  IdentifierHash cell_hash = m_calocell_id->calo_cell_hash( cellid );
324  cellInd = cellContainer->findIndex(cell_hash);
325  calcTILELayerSub(cellid);
326 
327  energyGeV = (*it1)->energy()*(1./GeV);
328  energyVec.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
329  energyAllTile += energyGeV;
330 
331  idVec.push_back(DataType( (Identifier::value_type)(*it1)->ID().get_compact() ));
332  phi.push_back(DataType((*it1)->phi()));
333  eta.push_back(DataType((*it1)->eta()));
334 
335  if (m_doTileDigit && tileDigits.isValid()) {
336 
337  if ( !pmt1digit[cellInd].empty()) {
338  for (int i=0; i<nTileSamples; i++) {
339  adcCounts1Str="adcCounts1 multiple=\""+DataType(nTileSamples).toString()+"\"";
340  adcCounts1Vec.push_back(DataType( int(pmt1digit[cellInd][i])));
341  }
342  }
343  else {
344  for (int i=0; i<nTileSamples; i++) {
345  adcCounts1Str="adcCounts1 multiple=\""+DataType(nTileSamples).toString()+"\"";
346  adcCounts1Vec.push_back(DataType(0));
347  }
348  }
349 
350 
351  if ( !pmt2digit[cellInd].empty()) {
352  for (int i=0; i<nTileSamples; i++) {
353  adcCounts2Str="adcCounts2 multiple=\""+DataType(nTileSamples).toString()+"\"";
354  adcCounts2Vec.push_back(DataType( int(pmt2digit[cellInd][i])));
355  }
356  }
357  else {
358  for (int i=0; i<nTileSamples; i++) {
359  adcCounts2Str= "adcCounts2 multiple=\""+DataType(nTileSamples).toString()+"\"";
360  adcCounts2Vec.push_back(DataType(0));
361  }
362  }
363  }
364 
365  if (m_doTileCellDetails) {
366 
367  const TileCell* theTileCell = dynamic_cast<const TileCell *>(*it1);
368  if (not theTileCell) {
369  //should never happen
370  throw std::runtime_error("Could not cast pointer to TileCell in CaloTileRetriever::getCaloTileData");
371  }
372  int gain1 = theTileCell->gain1();
373  int qual1 = theTileCell->qual1();
374  bool badch1 = theTileCell->badch1();
375  bool noch1 = (gain1<0 || gain1>1);
376 
377  int qual2 = theTileCell->qual2();
378  int gain2 = theTileCell->gain2();
379  bool badch2 = theTileCell->badch2();
380  bool noch2 = (gain2<0 || gain2>1);
381 
382  if (badch1 != badch2 && qual1 != qual2 && qual1 < 255 && qual2 < 255) {
383  if (badch1 && !noch1) gain1 = 1 - gain1;
384  if (badch2 && !noch1) gain2 = 1 - gain2;
385  }
386  if (badch1) qual1 = -qual1;
387  if (badch2) qual2 = -qual2;
388 
389  pmt1Energy.push_back(DataType(theTileCell->ene1()*(1./GeV)));
390  pmt1Time.push_back(DataType(theTileCell->time1()));
391  pmt1Chi2.push_back(DataType(qual1));
392  pmt1Gain.push_back(DataType(gain1));
393 
394  pmt2Energy.push_back(DataType(theTileCell->ene2()*(1./GeV)));
395  pmt2Time.push_back(DataType(theTileCell->time2()));
396  pmt2Chi2.push_back(DataType(qual2));
397  pmt2Gain.push_back(DataType(gain2));
398 
399  if (offlineRch && RawChannelCnt.isValid()
400  && (noch1 || pmt1number[cellInd]!=0) && (noch2 || pmt2number[cellInd]!=0)) {
401 
402  uint32_t tileAdcStatus = pmt1status[cellInd];
403  if (badch1) tileAdcStatus += 10;
404 
405  pmt1RawAmplitude.push_back(DataType(pmt1rawamp[cellInd]));
406  pmt1RawTime.push_back(DataType(pmt1rawtime[cellInd]));
407  pmt1Pedestal.push_back(DataType(pmt1ped[cellInd]));
408  pmt1Number.push_back(DataType(pmt1number[cellInd]));
409  pmt1ADCStatus.push_back(DataType(tileAdcStatus));
410 
411  tileAdcStatus = pmt2status[cellInd];
412  if (badch2) tileAdcStatus += 10;
413 
414  pmt2RawAmplitude.push_back(DataType(pmt2rawamp[cellInd]));
415  pmt2RawTime.push_back(DataType(pmt2rawtime[cellInd]));
416  pmt2Pedestal.push_back(DataType(pmt2ped[cellInd]));
417  pmt2Number.push_back(DataType(pmt2number[cellInd]));
418  pmt2ADCStatus.push_back(DataType(tileAdcStatus));
419  }
420  else {
421 
422  float maxTime = (tileInfo->NdigitSamples()/2) * 25;
423 
424  if (noch1 /* || pmt1digit[cellInd].empty() */ ) { //invalid gain - channel missing or digits not include in DPD
425  pmt1RawAmplitude.push_back(DataType(0));
426  pmt1RawTime.push_back(DataType(0));
427  pmt1ADCStatus.push_back(DataType(0));
428  pmt1Number.push_back(DataType(0));
429  pmt1Pedestal.push_back(DataType(0)); //The is no pedestal in DPD.
430  } else {
431  HWIdentifier hwid = cabling->s2h_adc_id(tileID->adc_id(cellid,0,gain1));
432 
433  int adc = tileHWID->adc(hwid);
434  int channel = tileHWID->channel(hwid);
435  int drawer = tileHWID->drawer(hwid);
436  int ros = tileHWID->ros(hwid);
437  int PMT = abs( cabling->channel2hole(ros,channel) );
438  int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
439  float scale = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0,
440  TileRawChannelUnit::ADCcounts, TileRawChannelUnit::MegaElectronVolts);
441  float amp = theTileCell->ene1() / scale;
442  float time = theTileCell->time1();
443 
444  int qbit = (theTileCell->qbit1() & TileCell::MASK_TIME);
445  if ((qual1 != 0 || qbit != 0 || amp != 0.0) && (fabs(time) < maxTime && time != 0.0)) {
446  time += m_tileToolTiming->getSignalPhase(drawerIdx, channel, adc);
447  }
448 
449  uint32_t tileAdcStatus = m_tileBadChanTool->encodeStatus(m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc));
450  if (badch1) tileAdcStatus += 10;
451 
452  pmt1RawAmplitude.push_back(DataType(amp));
453  pmt1RawTime.push_back(DataType(time));
454  pmt1Number.push_back(DataType(PMT));
455  pmt1ADCStatus.push_back(DataType( tileAdcStatus ));
456  pmt1Pedestal.push_back(DataType(0)); //The is no pedestal in DPD . This line is temporary.
457  }
458 
459  if (noch2 /* || pmt2digit[cellInd].empty() */ ) { //invalid gain - channel missing
460  pmt2RawAmplitude.push_back(DataType(0));
461  pmt2RawTime.push_back(DataType(0));
462  pmt2ADCStatus.push_back(DataType(0));
463  pmt2Number.push_back(DataType(0));
464  pmt2Pedestal.push_back(DataType(0)); //The is no pedestal in DPD
465  } else {
466  HWIdentifier hwid = cabling->s2h_adc_id(tileID->adc_id(cellid,1,gain2));
467 
468  int adc = tileHWID->adc(hwid);
469  int channel = tileHWID->channel(hwid);
470  int drawer = tileHWID->drawer(hwid);
471  int ros = tileHWID->ros(hwid);
472  int PMT = abs( cabling->channel2hole(ros,channel) );
473  int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
474  float scale = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0,
475  TileRawChannelUnit::ADCcounts, TileRawChannelUnit::MegaElectronVolts);
476  float amp = theTileCell->ene2() / scale;
477  float time = theTileCell->time2();
478 
479  int qbit = (theTileCell->qbit2() & TileCell::MASK_TIME);
480  if ((qual2 != 0 || qbit != 0 || amp != 0.0) && (fabs(time) < maxTime && time != 0.0)) {
481  time += m_tileToolTiming->getSignalPhase(drawerIdx, channel, adc);
482  }
483 
484  uint32_t tileAdcStatus = m_tileBadChanTool->encodeStatus(m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc));
485  if (badch2) tileAdcStatus += 10;
486 
487  pmt2RawAmplitude.push_back(DataType(amp));
488  pmt2RawTime.push_back(DataType(time));
489  pmt2ADCStatus.push_back(DataType( tileAdcStatus ));
490  pmt2Number.push_back(DataType(PMT));
491  pmt2Pedestal.push_back(DataType(0)); //The is no pedestal in DPD .
492  }
493  } //don't have TileRawChannel
494  } //if (m_doTileCellDetails)
495  } // end cell iterator
496 
497  ATH_MSG_DEBUG( " Total energy in Tile in GeV : " << energyAllTile );
498 
499  if ( !pmt1digit.empty() ) pmt1digit.clear();
500  if ( !pmt2digit.empty() ) pmt2digit.clear();
501 
502  // write values into DataMap
503  auto n = phi.size();
504  DataMap["phi"] = std::move(phi);
505  DataMap["eta"] = std::move(eta);
506  DataMap["sub"] = m_sub;
507  DataMap["id"] = std::move(idVec);
508  DataMap["energy"] = std::move(energyVec);
509 
510 
511  //BadCells
512  if (m_doBadTile==true) {
513  DataMap["BadCell"]= std::move(BadCell);
514  }
515 
516  if (m_doTileCellDetails) {
517  DataMap["pmt1Energy"] = std::move(pmt1Energy);
518  DataMap["pmt1Time"] = std::move(pmt1Time);
519  DataMap["pmt1Chi2"] = std::move(pmt1Chi2);
520  DataMap["pmt1Gain"] = std::move(pmt1Gain);
521 
522  DataMap["pmt2Energy"] = std::move(pmt2Energy);
523  DataMap["pmt2Time"] = std::move(pmt2Time);
524  DataMap["pmt2Chi2"] = std::move(pmt2Chi2);
525  DataMap["pmt2Gain"] = std::move(pmt2Gain);
526 
527  DataMap["pmt1RawAmplitude"] = std::move(pmt1RawAmplitude);
528  DataMap["pmt1RawTime"] = std::move(pmt1RawTime);
529  DataMap["pmt1ADCStatus"] = std::move(pmt1ADCStatus);
530  DataMap["pmt1Number"] = std::move(pmt1Number);
531  DataMap["pmt1Pedestal"] = std::move(pmt1Pedestal);
532 
533  DataMap["pmt2RawAmplitude"] = std::move(pmt2RawAmplitude);
534  DataMap["pmt2RawTime"] = std::move(pmt2RawTime);
535  DataMap["pmt2ADCStatus"] = std::move(pmt2ADCStatus);
536  DataMap["pmt2Number"] = std::move(pmt2Number);
537  DataMap["pmt2Pedestal"] = std::move(pmt2Pedestal);
538  }
539 
540  DataMap[adcCounts1Str] = std::move( adcCounts1Vec);
541  DataMap[adcCounts2Str] = std::move(adcCounts2Vec);
542 
543  //Be verbose
544  ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << n << " entries" );
545 
546  //All collections retrieved okay
547  return DataMap;
548 
549  } // getTileData

◆ initialize()

StatusCode JiveXML::CaloTileRetriever::initialize ( )

Default AthAlgTool methods.

Initialise the ToolSvc.

Definition at line 67 of file CaloTileRetriever.cxx.

67  {
68 
69  ATH_MSG_DEBUG( "Initialising Tool" );
70  ATH_CHECK( detStore()->retrieve (m_calocell_id, "CaloCell_ID") );
71 
72  //=== get TileCondToolTiming
73  ATH_CHECK( m_tileToolTiming.retrieve() );
74 
75  //=== get TileCondToolEmscale
76  ATH_CHECK( m_tileToolEmscale.retrieve() );
77 
78  //=== get TileBadChanTool
79  ATH_CHECK( m_tileBadChanTool.retrieve() );
80 
81  ATH_CHECK( m_sgKey.initialize() );
82 
83  ATH_CHECK( m_sgKeyTileDigits.initialize(m_doTileDigit) );
84 
85  ATH_CHECK( m_sgKeyTileRawChannel.initialize(m_doTileCellDetails) );
86 
87  return StatusCode::SUCCESS;
88  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

const InterfaceID & JiveXML::IDataRetriever::interfaceID ( )
inlinestaticinherited

Return the interface identifier.

Definition at line 40 of file IDataRetriever.h.

40 { return IID_IDataRetriever; }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::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< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ retrieve()

StatusCode JiveXML::CaloTileRetriever::retrieve ( ToolHandle< IFormatTool > &  FormatTool)
virtual

Retrieve all the data.

Tile data retrieval from chosen collection.

Implements JiveXML::IDataRetriever.

Definition at line 93 of file CaloTileRetriever.cxx.

93  {
94 
95  ATH_MSG_DEBUG( "in retrieve()" );
96 
97  SG::ReadHandle<CaloCellContainer> cellContainer(m_sgKey);
98  if (!cellContainer.isValid()){
99  ATH_MSG_WARNING( "Could not retrieve Calorimeter Cells " );
100  }
101  else{
102  if (m_tile) {
103  DataMap data = getCaloTileData(&(*cellContainer));
104  ATH_CHECK( FormatTool->AddToEvent("TILE", m_sgKey.key(), &data) );
105  ATH_MSG_DEBUG( "Tile retrieved" );
106  }
107  }
108 
109  //Tile cells retrieved okay
110  return StatusCode::SUCCESS;
111  }

◆ sysInitialize()

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

Perform system initialization for an algorithm.

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

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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_calocell_id

const CaloCell_ID* JiveXML::CaloTileRetriever::m_calocell_id
private

Definition at line 77 of file CaloTileRetriever.h.

◆ m_cellEnergyPrec

int JiveXML::CaloTileRetriever::m_cellEnergyPrec
private

Definition at line 83 of file CaloTileRetriever.h.

◆ m_cellThreshold

double JiveXML::CaloTileRetriever::m_cellThreshold
private

Definition at line 82 of file CaloTileRetriever.h.

◆ m_cellTimePrec

int JiveXML::CaloTileRetriever::m_cellTimePrec
private

Definition at line 84 of file CaloTileRetriever.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doBadTile

bool JiveXML::CaloTileRetriever::m_doBadTile
private

Definition at line 88 of file CaloTileRetriever.h.

◆ m_doTileCellDetails

bool JiveXML::CaloTileRetriever::m_doTileCellDetails
private

Definition at line 87 of file CaloTileRetriever.h.

◆ m_doTileDigit

bool JiveXML::CaloTileRetriever::m_doTileDigit
private

Definition at line 86 of file CaloTileRetriever.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_sgKey

SG::ReadHandleKey<CaloCellContainer> JiveXML::CaloTileRetriever::m_sgKey {this, "StoreGateKey", "AllCalo", "Name of the CaloCellContainer"}
private

Definition at line 79 of file CaloTileRetriever.h.

◆ m_sgKeyTileDigits

SG::ReadHandleKey<TileDigitsContainer> JiveXML::CaloTileRetriever::m_sgKeyTileDigits {this, "TileDigitsContainerKey", "", "Name of the TileDigitsContainer"}
private

Definition at line 80 of file CaloTileRetriever.h.

◆ m_sgKeyTileRawChannel

SG::ReadHandleKey<TileRawChannelContainer> JiveXML::CaloTileRetriever::m_sgKeyTileRawChannel {this, "TileRawChannelContainerKey", "", "Name of the TileRawChannelContainer"}
private

Definition at line 81 of file CaloTileRetriever.h.

◆ m_sub

DataVect JiveXML::CaloTileRetriever::m_sub
private

Definition at line 90 of file CaloTileRetriever.h.

◆ m_tile

bool JiveXML::CaloTileRetriever::m_tile
private

Definition at line 85 of file CaloTileRetriever.h.

◆ m_tileBadChanTool

ToolHandle<ITileBadChanTool> JiveXML::CaloTileRetriever::m_tileBadChanTool
private
Initial value:
{this,
"TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"}

Definition at line 73 of file CaloTileRetriever.h.

◆ m_tileToolEmscale

ToolHandle<TileCondToolEmscale> JiveXML::CaloTileRetriever::m_tileToolEmscale
private
Initial value:
{this,
"TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"}

Definition at line 70 of file CaloTileRetriever.h.

◆ m_tileToolTiming

ToolHandle<TileCondToolTiming> JiveXML::CaloTileRetriever::m_tileToolTiming
private
Initial value:
{this,
"TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"}

Definition at line 67 of file CaloTileRetriever.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
TileCell
Definition: TileCell.h:57
JiveXML::CaloTileRetriever::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Definition: CaloTileRetriever.h:73
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
JiveXML::CaloTileRetriever::getCaloTileData
const DataMap getCaloTileData(const CaloCellContainer *cellContainer)
Retrieve Tile cell location and details.
Definition: CaloTileRetriever.cxx:118
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
JiveXML::CaloTileRetriever::m_calocell_id
const CaloCell_ID * m_calocell_id
Definition: CaloTileRetriever.h:77
JiveXML::CaloTileRetriever::dataTypeName
virtual std::string dataTypeName() const
Return the name of the data type.
Definition: CaloTileRetriever.h:61
CaloCell_Base_ID::calo_cell_hash
IdentifierHash calo_cell_hash(const Identifier cellId) const
create hash id from 'global' cell id
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
JiveXML::CaloTileRetriever::m_doTileCellDetails
bool m_doTileCellDetails
Definition: CaloTileRetriever.h:87
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
TileInfo::NdigitSamples
int NdigitSamples() const
Returns the number of sammples (digits) per event.
Definition: TileInfo.h:75
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JiveXML::DataVect
std::vector< DataType > DataVect
Defines a map with a key and a vector of DataType objects e.g.
Definition: DataType.h:58
DataType
OFFLINE_FRAGMENTS_NAMESPACE::PointerType DataType
Definition: RoIBResultByteStreamTool.cxx:25
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
CaloTime_fillDB.gain2
gain2
Definition: CaloTime_fillDB.py:357
CaloCellContainer::beginConstCalo
CaloCellContainer::const_iterator beginConstCalo(CaloCell_ID::SUBCALO caloNum) const
get const iterators on cell of just one calo
Definition: CaloCellContainer.cxx:119
JiveXML::CaloTileRetriever::m_sgKeyTileDigits
SG::ReadHandleKey< TileDigitsContainer > m_sgKeyTileDigits
Definition: CaloTileRetriever.h:80
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
JiveXML::CaloTileRetriever::m_sub
DataVect m_sub
Definition: CaloTileRetriever.h:90
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
TileInfo
Definition: TileInfo.h:49
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
JiveXML::CaloTileRetriever::m_cellThreshold
double m_cellThreshold
Definition: CaloTileRetriever.h:82
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
CaloCell_Base_ID::is_tile_barrel
bool is_tile_barrel(const Identifier id) const
test if the id belongs to the Tiles barrel
TileFragHash::OptFilterDsp
@ OptFilterDsp
Definition: TileFragHash.h:34
empty
bool empty(TH1 *h)
Definition: computils.cxx:295
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
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
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
TileHWID
Helper class for TileCal online (hardware) identifiers.
Definition: TileHWID.h:49
JiveXML::CaloTileRetriever::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: CaloTileRetriever.h:70
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
Index
IndexedConstituentUserInfo::Index Index
Definition: IndexedConstituentUserInfo.cxx:12
AthCommonDataStore
Definition: AthCommonDataStore.h:52
JiveXML::CaloTileRetriever::m_doBadTile
bool m_doBadTile
Definition: CaloTileRetriever.h:88
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
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileID
Helper class for TileCal offline identifiers.
Definition: TileID.h:68
beamspotman.n
n
Definition: beamspotman.py:731
DetDescrDictionaryDict::it1
std::vector< HWIdentifier >::iterator it1
Definition: DetDescrDictionaryDict.h:17
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloCell_Base_ID::is_tile_extbarrel
bool is_tile_extbarrel(const Identifier id) const
test if the id belongs to the Tiles extended barrel
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CaloCell_Base_ID::TILE
@ TILE
Definition: CaloCell_Base_ID.h:46
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
JiveXML::CaloTileRetriever::calcTILELayerSub
void calcTILELayerSub(Identifier &)
Definition: CaloTileRetriever.cxx:553
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
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Tile_Base_ID::adc_id
Identifier adc_id(const Identifier &cell_id, int pmt, int adc) const
Definition: Tile_Base_ID.cxx:802
CaloTime_fillDB.gain1
gain1
Definition: CaloTime_fillDB.py:356
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
JiveXML::CaloTileRetriever::m_tile
bool m_tile
Definition: CaloTileRetriever.h:85
JiveXML::CaloTileRetriever::m_cellTimePrec
int m_cellTimePrec
Definition: CaloTileRetriever.h:84
TileRawDataContainer::get_type
TYPE get_type() const
Definition: TileRawDataContainer.h:62
JiveXML::CaloTileRetriever::m_tileToolTiming
ToolHandle< TileCondToolTiming > m_tileToolTiming
Definition: CaloTileRetriever.h:67
TileCell::MASK_TIME
@ MASK_TIME
Definition: TileCell.h:67
JiveXML::CaloTileRetriever::m_sgKey
SG::ReadHandleKey< CaloCellContainer > m_sgKey
Definition: CaloTileRetriever.h:79
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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
JiveXML::CaloTileRetriever::retrieve
virtual StatusCode retrieve(ToolHandle< IFormatTool > &FormatTool)
Retrieve all the data.
Definition: CaloTileRetriever.cxx:93
CaloCell_Base_ID::is_tile_negative
bool is_tile_negative(const Identifier id) const
test if the id belongs to the Tiles negative side
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
CaloCellContainer::endConstCalo
CaloCellContainer::const_iterator endConstCalo(CaloCell_ID::SUBCALO caloNum) const
Definition: CaloCellContainer.cxx:133
CaloCellContainer::findIndex
int findIndex(const IdentifierHash theHash) const
Return index of the cell with a given hash.
Definition: CaloCellContainer.cxx:363
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
Identifier::value_type
unsigned long long value_type
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:27
JiveXML::CaloTileRetriever::m_doTileDigit
bool m_doTileDigit
Definition: CaloTileRetriever.h:86
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
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
JiveXML::CaloTileRetriever::m_cellEnergyPrec
int m_cellEnergyPrec
Definition: CaloTileRetriever.h:83
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
JiveXML::CaloTileRetriever::m_sgKeyTileRawChannel
SG::ReadHandleKey< TileRawChannelContainer > m_sgKeyTileRawChannel
Definition: CaloTileRetriever.h:81
TileRawChannelUnit::ADCcounts
@ ADCcounts
Definition: TileRawChannelUnit.h:17
fitman.k
k
Definition: fitman.py:528
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 22:01:34 for ATLAS Offline Software by   doxygen 1.8.18