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::LArDigitRetriever Class Reference

Retrieves all Tile Calo Cell objects. More...

#include <LArDigitRetriever.h>

Inheritance diagram for JiveXML::LArDigitRetriever:
Collaboration diagram for JiveXML::LArDigitRetriever:

Public Member Functions

 LArDigitRetriever (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 getLArDigitData (const CaloCellContainer *cellContainer, const std::string &datatype, CaloCell_ID::SUBCALO calotype)
 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 calcEMLayerSub (Identifier &)
 
void calcHECLayerSub (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

SG::ReadHandleKey< CaloCellContainer > m_sgKey {this, "StoreGateKey", "AllCalo", "Name of the CaloCellContainer"}
 
SG::ReadHandleKey< LArDigitContainer > m_sgKeyLArDigit_raw {this, "StoreGateKey", "FREE", "Name of the LArDigitContainer"}
 
SG::ReadHandleKey< LArDigitContainer > m_sgKeyLArDigit_esd {this, "StoreGateKey", "LArDigitContainer_Thinned", "Name of the LArDigitContainer"}
 
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArADC2MeV > m_adc2mevKey { this, "ADC2MeVKey", "LArADC2MeV", "SG Key of the LArADC2MeV CDO" }
 
const CaloCell_ID * m_calocell_id
 
bool m_lar
 
bool m_hec
 
bool m_fcal
 
bool m_doLArDigit
 
bool m_doHECDigit
 
bool m_doFCalDigit
 
bool m_doDigit
 
bool m_cellConditionCut
 
bool m_inputdpd
 
int m_cellEnergyPrec
 
int m_cellTimePrec
 
double m_cellThreshold
 
std::vector< Identifier::value_type > m_LArChannelsToIgnoreM5
 
bool m_doMaskLArChannelsM5
 
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 52 of file LArDigitRetriever.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

◆ LArDigitRetriever()

JiveXML::LArDigitRetriever::LArDigitRetriever ( 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 33 of file LArDigitRetriever.cxx.

33  :
34  AthAlgTool(type,name,parent),
35  m_calocell_id(nullptr)
36  {
37  //Only declare the interface
38  declareInterface<IDataRetriever>(this);
39 
40  m_doDigit = false;
41  m_inputdpd = false;
42 
43  declareProperty("CellThreshold", m_cellThreshold = 50.);
44  declareProperty("RetrieveLAr" , m_lar = true);
45  declareProperty("RetrieveHEC" , m_hec = true);
46  declareProperty("RetrieveFCAL" , m_fcal = true);
47  declareProperty("DoLArDigit", m_doLArDigit = false);
48  declareProperty("DoHECDigit", m_doHECDigit = false);
49  declareProperty("DoFCalDigit", m_doFCalDigit = false);
50  declareProperty("CellEnergyPrec", m_cellEnergyPrec = 3);
51  declareProperty("CellTimePrec", m_cellTimePrec = 3);
52 
53 // Check the cell conditions. Not present in MC data, so false by default. Switch to 'true'
54 // for real (commissioning) cells.
55  declareProperty("CellConditionCut", m_cellConditionCut = false);
56  declareProperty("LArChannelsToIgnoreM5", m_LArChannelsToIgnoreM5);
57  declareProperty("DoMaskLArChannelsM5", m_doMaskLArChannelsM5 = false);
58  }

Member Function Documentation

◆ calcEMLayerSub()

void JiveXML::LArDigitRetriever::calcEMLayerSub ( Identifier &  cellid)
private

Definition at line 484 of file LArDigitRetriever.cxx.

485  {
486  const auto posNeg = std::abs(m_calocell_id->pos_neg(cellid));
487  if (posNeg<1 or posNeg>3) return;
488  static constexpr std::array<int,3> datatypes{2,3,0};
489  m_sub.emplace_back(datatypes[posNeg-1]);
490  }

◆ calcHECLayerSub()

void JiveXML::LArDigitRetriever::calcHECLayerSub ( Identifier &  cellid)
private

Definition at line 494 of file LArDigitRetriever.cxx.

495  {
496  if(m_calocell_id->pos_neg(cellid)==2)
497  m_sub.emplace_back(1);
498  else
499  m_sub.emplace_back(0);
500  }

◆ dataTypeName()

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

Return the name of the data type.

Implements JiveXML::IDataRetriever.

Definition at line 67 of file LArDigitRetriever.h.

67 { return "LArDigit"; };

◆ 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

◆ getLArDigitData()

const DataMap JiveXML::LArDigitRetriever::getLArDigitData ( const CaloCellContainer *  cellContainer,
const std::string &  datatype,
CaloCell_ID::SUBCALO  calotype 
)

Retrieve Tile cell location and details.

Parameters
FormatToolthe tool that will create formated output from the DataMap

Definition at line 123 of file LArDigitRetriever.cxx.

126  {
127 
128  //be verbose
129  ATH_MSG_DEBUG( "getLArDigitData()" );
130  const EventContext& ctx = Gaudi::Hive::currentContext();
131 
132  char rndStr[30];
133  DataMap DataMap;
134 
135  DataVect phi; phi.reserve(cellContainer->size());
136  DataVect eta; eta.reserve(cellContainer->size());
137  DataVect x; x.reserve(cellContainer->size());
138  DataVect y; y.reserve(cellContainer->size());
139  DataVect dx; dx.reserve(cellContainer->size());
140  DataVect dy; dy.reserve(cellContainer->size());
141 
142  DataVect energy; energy.reserve(cellContainer->size());
143  DataVect idVec; idVec.reserve(cellContainer->size());
144  DataVect channel; channel.reserve(cellContainer->size());
145  DataVect feedThrough; feedThrough.reserve(cellContainer->size());
146  DataVect slotVec; slotVec.reserve(cellContainer->size());
147 
148  DataVect cellTimeVec; cellTimeVec.reserve(cellContainer->size());
149  DataVect cellGain; cellGain.reserve(cellContainer->size());
150  DataVect cellPedestal; cellPedestal.reserve(cellContainer->size());
151  DataVect adc2Mev; adc2Mev.reserve(cellContainer->size());
152 
153 // m_sub; m_sub.reserve(cellContainer->size());
154  m_sub.clear(); // need to clear before each event, otherwise appended
155 
156  DataVect LArSampleIndexVec; LArSampleIndexVec.reserve(cellContainer->size());
157 
158  std::string LArSampleIndexStr="adcCounts multiple=\"0\"";
159 
160  SG::ReadHandle<LArDigitContainer> LArDigitCnt_raw_handle(m_sgKeyLArDigit_raw);
161  SG::ReadHandle<LArDigitContainer> LArDigitCnt_esd_handle(m_sgKeyLArDigit_esd);
162  const LArDigitContainer* LArDigitCnt = nullptr;
163  if (LArDigitCnt_raw_handle.isValid()) {
164  LArDigitCnt = &(*LArDigitCnt_raw_handle);
165  }
166  else if (LArDigitCnt_esd_handle.isValid()) {
167  LArDigitCnt = &(*LArDigitCnt_esd_handle);
168  m_inputdpd = true;
169  }
170  else {
171  ATH_MSG_WARNING( "Could not retrieve LArDigits" );
172  }
173 
174  const ILArPedestal* larPedestal = nullptr;
175  if ( detStore()->retrieve(larPedestal).isFailure()){
176  ATH_MSG_ERROR( "in getLArDigitData(), Could not retrieve LAr Pedestal" );
177  }
178 
179  const LArOnlineID* onlineId = nullptr;
180  if ( detStore()->retrieve(onlineId, "LArOnlineID").isFailure()) {
181  ATH_MSG_ERROR( "in getLArDigitData(),Could not get LArOnlineID!" );
182  }
183 
184  SG::ReadCondHandle<LArADC2MeV> adc2mev (m_adc2mevKey, ctx);
185 
186 //------------------------------------------------------
187 //Loop over the digits and find Cell (LAr,HEC, FCAL)
188 //------------------------------------------------------
189 
190  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey, ctx};
191  const LArOnOffIdMapping* cabling{*cablingHdl};
192  if(!cabling) {
193  ATH_MSG_ERROR( "Do not have cabling mapping from key " << m_cablingKey.key() );
194  return DataMap;
195  }
196 
197 
198  if (LArDigitCnt && m_doDigit==true) {
199 
200  auto pCellIndex = std::make_unique<std::array<int, 200000>>();
201  pCellIndex->fill(0);
202  int nLArSamples = 0;
203  HWIdentifier LArHardwareId;
204  Identifier LArId;
205 
206  double energyGeV,cellTime;
207 
208  for (const LArDigit* digit : *LArDigitCnt) {
209 
210  LArHardwareId = digit->hardwareID();
211  if (!cabling->isOnlineConnected(LArHardwareId))continue;
212 
213  LArId = cabling->cnvToIdentifier(LArHardwareId); //converter
214  const IdentifierHash cellhash=m_calocell_id->calo_cell_hash(LArId); //fast method to find cell
215 
216  int Index = cellContainer->findIndex(cellhash); //find Cell Index
217  if (Index >= 0)
218  (*pCellIndex)[Index] = Index;
219 
220  nLArSamples = digit->nsamples();
221  std::vector<short> LArSamples = digit->samples();
222  int largain = digit->gain();
223  int FT = onlineId->feedthrough(LArHardwareId);
224  int slot = onlineId->slot(LArHardwareId);
225  int larchan = onlineId->channel(LArHardwareId);
226  float pedestal=larPedestal->pedestal(LArHardwareId,largain);
227  float pedvalue=0;
228  if (pedestal >= (1.0+LArElecCalib::ERRORCODE)) pedvalue = pedestal;
229  else pedvalue = LArSamples[0];
230 
231  LArVectorProxy polynom_adc2mev = adc2mev->ADC2MEV(LArId,largain);
232 
233  if ( Index >= 0 ){ // can be -1
234  if ( (*cellContainer)[Index]->energy() >m_cellThreshold) {
235 
236  if (((((*cellContainer)[Index]->provenance())&0xFF)!=0xA5)&&m_cellConditionCut) continue; // check full conition for LAr Cells
237 
238  //ignore LAr, HEC, and/or FCAL cells that are to be masked
239  if (m_doMaskLArChannelsM5){
240  bool maskChannel = false;
241  for (size_t i = 0; i < m_LArChannelsToIgnoreM5.size(); i++){
242  if ( (*cellContainer)[Index]->ID().get_compact() == m_LArChannelsToIgnoreM5[i]){
243  maskChannel = true;
244  break; // exit loop over bad channels
245  }
246  }
247  if (maskChannel) continue; // continue loop over all channels
248  }
249 
250 
251  if (datatype == "LAr" && m_calocell_id->is_em(LArId)) {
252 
253  calcEMLayerSub(LArId);
254 
255  energyGeV = (*cellContainer)[Index]->energy() * (1./GeV);
256  energy.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
257  idVec.push_back(DataType((*cellContainer)[Index]->ID().get_compact() ));
258  phi.push_back(DataType((*cellContainer)[Index]->phi()));
259  eta.push_back(DataType((*cellContainer)[Index]->eta()));
260 
261  cellTime = (*cellContainer)[Index]->time();
262  cellTimeVec.push_back(DataType( gcvt( cellTime, m_cellTimePrec, rndStr) ) );
263  cellPedestal.push_back(DataType(pedvalue));
264  cellGain.push_back(DataType(largain));
265  channel.push_back(DataType(larchan));
266  feedThrough.push_back(DataType(FT));
267  slotVec.push_back(DataType(slot));
268  if (polynom_adc2mev.size()==0){
269  adc2Mev.push_back(DataType(-1));
270  }else{
271  adc2Mev.push_back(DataType(polynom_adc2mev[1]));
272  }
273  if ( m_doLArDigit ) {
274  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
275  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(LArSamples[i]));
276  }
277  } //match datatype LAr
278 
279  else if(datatype == "HEC" && m_calocell_id->is_hec(LArId)) {
280 
281  calcHECLayerSub(LArId);
282  energyGeV = (*cellContainer)[Index]->energy() * (1./GeV);
283  energy.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
284  idVec.push_back(DataType((*cellContainer)[Index]->ID().get_compact() ));
285  phi.push_back(DataType((*cellContainer)[Index]->phi()));
286  eta.push_back(DataType((*cellContainer)[Index]->eta()));
287 
288 
289  cellTime = (*cellContainer)[Index]->time();
290  cellTimeVec.push_back(DataType( gcvt( cellTime, m_cellTimePrec, rndStr) ) );
291  cellPedestal.push_back(DataType(pedvalue));
292  cellGain.push_back(DataType(largain));
293  channel.push_back(DataType(larchan));
294  feedThrough.push_back(DataType(FT));
295  slotVec.push_back(DataType(slot));
296  if (polynom_adc2mev.size()==0)
297  adc2Mev.push_back(DataType(-1));
298  else
299  adc2Mev.push_back(DataType(polynom_adc2mev[1]));
300  if (m_doHECDigit){
301  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
302  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(LArSamples[i]));
303  }
304  }//match datatype HEC
305 
306  else if(datatype == "FCAL" && m_calocell_id->is_fcal(LArId)) {
307 
308  energyGeV = (*cellContainer)[Index]->energy() * (1./GeV);
309  energy.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
310  idVec.push_back(DataType((*cellContainer)[Index]->ID().get_compact() ));
311  x.push_back(DataType((*cellContainer)[Index]->x() *0.1));
312  y.push_back(DataType((*cellContainer)[Index]->y() *0.1));
313 
314  const CaloDetDescrElement* elt = (*cellContainer)[Index]->caloDDE();
315 
316  dx.push_back(DataType(elt->dx()*0.1));
317  dy.push_back(DataType(elt->dy()*0.1));
318 
319  if (m_calocell_id->pos_neg(LArId)==2) m_sub.push_back(DataType(1));
320  else m_sub.push_back(DataType(0));
321 
322 
323  cellTime = (*cellContainer)[Index]->time();
324  cellTimeVec.push_back(DataType( gcvt( cellTime, m_cellTimePrec, rndStr) ) );
325  cellPedestal.push_back(DataType(pedvalue));
326  cellGain.push_back(DataType(largain));
327  channel.push_back(DataType(larchan));
328  feedThrough.push_back(DataType(FT));
329  slotVec.push_back(DataType(slot));
330  if (polynom_adc2mev.size()==0)
331  adc2Mev.push_back(DataType(-1));
332  else
333  adc2Mev.push_back(DataType(polynom_adc2mev[1]));
334  if (m_doFCalDigit){
335  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
336  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(LArSamples[i]));
337  }
338  }//match datatype FCAL
339  } //if cellThreshold
340  } // if Index >0
341  } //digit
342 
343 
344 // If the digits are retrived from DPD, retrieve the other cells which do not have the digits avaliable
345 
346  if (m_inputdpd) {
347 
348  CaloCellContainer::const_iterator it1 = cellContainer->beginConstCalo(calotype);
349  CaloCellContainer::const_iterator it2 = cellContainer->endConstCalo(calotype);
350 
351 
352  for (;it1!=it2;++it1) {
353  //---------------------------------------------
354 
355  if ( (*it1)->energy() < m_cellThreshold ) continue;
356 
357  Identifier cellid = (*it1)->ID();
358 
359  const IdentifierHash cellhash=m_calocell_id->calo_cell_hash(cellid); //fast method to find cell
360  int Index = cellContainer->findIndex(cellhash); //find Cell Index
361  if (Index >= 0 && (*pCellIndex)[Index] == Index)
362  continue; //test whether this cell was already retrieved
363 
364  HWIdentifier LArhwid = cabling->createSignalChannelIDFromHash((*it1)->caloDDE()->calo_hash());
365 
366  if (m_calocell_id->is_tile(cellid) ) continue;
367  if (((((*it1)->provenance())&0xFF)!=0xA5)&&m_cellConditionCut) continue; // check full condition for LAr cells
368 
369  //ignore LAr, HEC, and/or FCAL cells that are to be masked
370  if (m_doMaskLArChannelsM5){
371  bool maskChannel = false;
372  for (size_t i = 0; i < m_LArChannelsToIgnoreM5.size(); i++){
373  if (cellid == m_LArChannelsToIgnoreM5[i]){
374  maskChannel = true;
375  break; // exit loop over bad channels
376  }
377  }
378  if (maskChannel) continue; // continue loop over all channels
379  }
380 
381  energyGeV = (*it1)->energy()*(1./GeV);
382  energy.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
383  idVec.push_back(DataType((*it1)->ID().get_compact() ));
384  channel.push_back(DataType(onlineId->channel(LArhwid)));
385  feedThrough.push_back(DataType(onlineId->feedthrough(LArhwid)));
386  slotVec.push_back(DataType(onlineId->slot(LArhwid)));
387 
388  cellTime = (*it1)->time();
389  cellTimeVec.push_back(DataType( gcvt( cellTime, m_cellTimePrec, rndStr) ) );
390  cellGain.push_back(DataType((*it1)->gain()));
391  int largain = (*it1)->gain();
392  float pedvalue=0;
393  float pedestal=larPedestal->pedestal(LArhwid,largain);
394  if (pedestal >= (1.0+LArElecCalib::ERRORCODE)) pedvalue = pedestal;
395  else pedvalue = 0;
396  cellPedestal.push_back(DataType(pedvalue));
397 
398  LArVectorProxy polynom_adc2mev = adc2mev->ADC2MEV(cellid,largain);
399  if (polynom_adc2mev.size()==0){
400  adc2Mev.push_back(DataType(-1));
401  }else{
402  adc2Mev.push_back(DataType(polynom_adc2mev[1]));
403  }
404 
405 
406  if (datatype == "LAr") {
407  calcEMLayerSub(cellid);
408  phi.push_back(DataType((*it1)->phi()));
409  eta.push_back(DataType((*it1)->eta()));
410  if ( m_doLArDigit ) {
411  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
412  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(0)); }
413  }
414 
415  else if (datatype == "HEC") {
416  calcHECLayerSub(cellid);
417  phi.push_back(DataType((*it1)->phi()));
418  eta.push_back(DataType((*it1)->eta()));
419  if (m_doHECDigit){
420  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
421  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(0)); }
422  }
423 
424  else if (datatype == "FCAL") {
425 
426  x.push_back(DataType( (*it1)->x()*0.1 ));
427  y.push_back(DataType( (*it1)->y()*0.1 ));
428 
429  const CaloDetDescrElement* elt = (*it1)->caloDDE();
430  dx.push_back(DataType( elt->dx()*0.1 ));
431  dy.push_back(DataType( elt->dy()*0.1 ));
432 
433  if (m_calocell_id->pos_neg(cellid)==2) m_sub.push_back(DataType(1));
434  else m_sub.push_back(DataType(0));
435  if (m_doFCalDigit){
436  LArSampleIndexStr="adcCounts multiple=\""+DataType(nLArSamples).toString()+"\"";
437  for(int i=0; i<nLArSamples; i++) LArSampleIndexVec.push_back(DataType(0));
438  }
439  }
440 
441  }//for(;it1!=it2;it1++)
442  }// if (m_inputdpd)
443  }
444 
445 //----------------above lines are trying to get the LAr,HEC and FCAL tags --------------
446 
447  // write values into DataMap
448  const auto nEntries = phi.size();
449  if(!(datatype=="FCAL")){
450  DataMap["phi"] = std::move(phi);
451  DataMap["eta"] = std::move(eta);
452  } else {
453  DataMap["x"] = std::move(x);
454  DataMap["y"] = std::move(y);
455  DataMap["dx"] = std::move(dx);
456  DataMap["dy"] = std::move(dy);
457  }
458 
459  DataMap["energy"] = std::move(energy);
460  DataMap["id"] = std::move(idVec);
461  DataMap["channel"] = std::move(channel);
462  DataMap["feedThrough"] = std::move(feedThrough);
463  DataMap["slot"] = std::move(slotVec);
464 
465  // adc counts
466  DataMap["cellTime"] = std::move(cellTimeVec);
467  DataMap["cellGain"] = std::move(cellGain);
468  DataMap["cellPedestal"] = std::move(cellPedestal);
469  DataMap["adc2Mev"] = std::move(adc2Mev);
470 
471  DataMap[LArSampleIndexStr] = LArSampleIndexVec; // adcCounts
472 
473  //Be verbose
474  ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << nEntries<< " entries" );
475 
476  //All collections retrieved okay
477  return DataMap;
478 
479  } // getTileData

◆ initialize()

StatusCode JiveXML::LArDigitRetriever::initialize ( )

Default AthAlgTool methods.

Initialise the ToolSvc.

Definition at line 64 of file LArDigitRetriever.cxx.

64  {
65 
66  ATH_MSG_DEBUG( "Initialising Tool" );
67  ATH_CHECK( detStore()->retrieve (m_calocell_id, "CaloCell_ID") );
68  ATH_CHECK( m_adc2mevKey.initialize() );
69 
70  ATH_CHECK( m_sgKey.initialize() );
71  ATH_CHECK( m_sgKeyLArDigit_raw.initialize() );
72  ATH_CHECK( m_sgKeyLArDigit_esd.initialize() );
73  ATH_CHECK( m_cablingKey.initialize() );
74 
75  return StatusCode::SUCCESS;
76  }

◆ 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::LArDigitRetriever::retrieve ( ToolHandle< IFormatTool > &  FormatTool)
virtual

Retrieve all the data.

Tile data retrieval from chosen collection.

Implements JiveXML::IDataRetriever.

Definition at line 81 of file LArDigitRetriever.cxx.

81  {
82 
83  ATH_MSG_DEBUG( "in retrieve()" );
84 
85  if (m_doLArDigit || m_doHECDigit || m_doFCalDigit){
86  m_doDigit = true;
87  }
88 
89  SG::ReadHandle<CaloCellContainer> cellContainer(m_sgKey);
90  if (!cellContainer.isValid()){
91  ATH_MSG_WARNING( "Could not retrieve Calorimeter Cells " );
92  }
93  else{
94 
95  if(m_fcal){
96  DataMap data = getLArDigitData(&(*cellContainer),"FCAL",CaloCell_ID::LARFCAL);
97  ATH_CHECK( FormatTool->AddToEvent("FCAL", m_sgKey.key(), &data) );
98  ATH_MSG_DEBUG( "FCAL retrieved" );
99  }
100 
101  if(m_lar){
102  DataMap data = getLArDigitData(&(*cellContainer),"LAr",CaloCell_ID::LAREM);
103  ATH_CHECK( FormatTool->AddToEvent("LAr", m_sgKey.key(), &data) );
104  ATH_MSG_DEBUG( "LAr retrieved" );
105  }
106 
107  if(m_hec){
108  DataMap data = getLArDigitData(&(*cellContainer),"HEC",CaloCell_ID::LARHEC);
109  ATH_CHECK( FormatTool->AddToEvent("HEC", m_sgKey.key(), &data) );
110  ATH_MSG_DEBUG( "HEC retrieved" );
111  }
112  }
113 
114  //Tile cells retrieved okay
115  return StatusCode::SUCCESS;
116  }

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

SG::ReadCondHandleKey<LArADC2MeV> JiveXML::LArDigitRetriever::m_adc2mevKey { this, "ADC2MeVKey", "LArADC2MeV", "SG Key of the LArADC2MeV CDO" }
private

Definition at line 81 of file LArDigitRetriever.h.

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> JiveXML::LArDigitRetriever::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
private

Definition at line 79 of file LArDigitRetriever.h.

◆ m_calocell_id

const CaloCell_ID* JiveXML::LArDigitRetriever::m_calocell_id
private

Definition at line 84 of file LArDigitRetriever.h.

◆ m_cellConditionCut

bool JiveXML::LArDigitRetriever::m_cellConditionCut
private

Definition at line 93 of file LArDigitRetriever.h.

◆ m_cellEnergyPrec

int JiveXML::LArDigitRetriever::m_cellEnergyPrec
private

Definition at line 95 of file LArDigitRetriever.h.

◆ m_cellThreshold

double JiveXML::LArDigitRetriever::m_cellThreshold
private

Definition at line 97 of file LArDigitRetriever.h.

◆ m_cellTimePrec

int JiveXML::LArDigitRetriever::m_cellTimePrec
private

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

bool JiveXML::LArDigitRetriever::m_doDigit
private

Definition at line 92 of file LArDigitRetriever.h.

◆ m_doFCalDigit

bool JiveXML::LArDigitRetriever::m_doFCalDigit
private

Definition at line 91 of file LArDigitRetriever.h.

◆ m_doHECDigit

bool JiveXML::LArDigitRetriever::m_doHECDigit
private

Definition at line 90 of file LArDigitRetriever.h.

◆ m_doLArDigit

bool JiveXML::LArDigitRetriever::m_doLArDigit
private

Definition at line 89 of file LArDigitRetriever.h.

◆ m_doMaskLArChannelsM5

bool JiveXML::LArDigitRetriever::m_doMaskLArChannelsM5
private

Definition at line 100 of file LArDigitRetriever.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_fcal

bool JiveXML::LArDigitRetriever::m_fcal
private

Definition at line 88 of file LArDigitRetriever.h.

◆ m_hec

bool JiveXML::LArDigitRetriever::m_hec
private

Definition at line 87 of file LArDigitRetriever.h.

◆ m_inputdpd

bool JiveXML::LArDigitRetriever::m_inputdpd
private

Definition at line 94 of file LArDigitRetriever.h.

◆ m_lar

bool JiveXML::LArDigitRetriever::m_lar
private

Definition at line 86 of file LArDigitRetriever.h.

◆ m_LArChannelsToIgnoreM5

std::vector<Identifier::value_type> JiveXML::LArDigitRetriever::m_LArChannelsToIgnoreM5
private

Definition at line 99 of file LArDigitRetriever.h.

◆ m_sgKey

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

Definition at line 76 of file LArDigitRetriever.h.

◆ m_sgKeyLArDigit_esd

SG::ReadHandleKey<LArDigitContainer> JiveXML::LArDigitRetriever::m_sgKeyLArDigit_esd {this, "StoreGateKey", "LArDigitContainer_Thinned", "Name of the LArDigitContainer"}
private

Definition at line 78 of file LArDigitRetriever.h.

◆ m_sgKeyLArDigit_raw

SG::ReadHandleKey<LArDigitContainer> JiveXML::LArDigitRetriever::m_sgKeyLArDigit_raw {this, "StoreGateKey", "FREE", "Name of the LArDigitContainer"}
private

Definition at line 77 of file LArDigitRetriever.h.

◆ m_sub

DataVect JiveXML::LArDigitRetriever::m_sub
private

Definition at line 102 of file LArDigitRetriever.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:
ILArPedestal::pedestal
virtual float pedestal(const HWIdentifier &id, int gain) const =0
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
JiveXML::LArDigitRetriever::m_hec
bool m_hec
Definition: LArDigitRetriever.h:87
JiveXML::LArDigitRetriever::m_sgKey
SG::ReadHandleKey< CaloCellContainer > m_sgKey
Definition: LArDigitRetriever.h:76
CaloCell_Base_ID::LARFCAL
@ LARFCAL
Definition: CaloCell_Base_ID.h:46
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
CaloCell_Base_ID::calo_cell_hash
IdentifierHash calo_cell_hash(const Identifier cellId) const
create hash id from 'global' cell id
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
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
ILArPedestal
Definition: ILArPedestal.h:12
JiveXML::LArDigitRetriever::m_doFCalDigit
bool m_doFCalDigit
Definition: LArDigitRetriever.h:91
CaloCell_Base_ID::pos_neg
int pos_neg(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
JiveXML::DataVect
std::vector< DataType > DataVect
Defines a map with a key and a vector of DataType objects e.g.
Definition: DataType.h:58
LArElecCalib::ERRORCODE
@ ERRORCODE
Definition: LArCalibErrorCode.h:17
JiveXML::LArDigitRetriever::m_fcal
bool m_fcal
Definition: LArDigitRetriever.h:88
DataType
OFFLINE_FRAGMENTS_NAMESPACE::PointerType DataType
Definition: RoIBResultByteStreamTool.cxx:25
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
JiveXML::LArDigitRetriever::m_calocell_id
const CaloCell_ID * m_calocell_id
Definition: LArDigitRetriever.h:84
CaloCellContainer::beginConstCalo
CaloCellContainer::const_iterator beginConstCalo(CaloCell_ID::SUBCALO caloNum) const
get const iterators on cell of just one calo
Definition: CaloCellContainer.cxx:119
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1957
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
CaloCell_Base_ID::LARHEC
@ LARHEC
Definition: CaloCell_Base_ID.h:46
LArSamples
Definition: AbsShape.h:24
JiveXML::LArDigitRetriever::m_doDigit
bool m_doDigit
Definition: LArDigitRetriever.h:92
JiveXML::LArDigitRetriever::m_cellThreshold
double m_cellThreshold
Definition: LArDigitRetriever.h:97
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
CaloCell_Base_ID::is_tile
bool is_tile(const Identifier id) const
test if the id belongs to the Tiles
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
JiveXML::DataMap
std::map< std::string, DataVect > DataMap
Definition: DataType.h:59
HWIdentifier
Definition: HWIdentifier.h:13
x
#define x
JiveXML::LArDigitRetriever::m_cellTimePrec
int m_cellTimePrec
Definition: LArDigitRetriever.h:96
JiveXML::LArDigitRetriever::m_sgKeyLArDigit_esd
SG::ReadHandleKey< LArDigitContainer > m_sgKeyLArDigit_esd
Definition: LArDigitRetriever.h:78
CaloCell_Base_ID::is_hec
bool is_hec(const Identifier id) const
test if the id belongs to the HEC
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
JiveXML::LArDigitRetriever::m_doHECDigit
bool m_doHECDigit
Definition: LArDigitRetriever.h:90
JiveXML::LArDigitRetriever::dataTypeName
virtual std::string dataTypeName() const
Return the name of the data type.
Definition: LArDigitRetriever.h:67
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
JiveXML::LArDigitRetriever::calcHECLayerSub
void calcHECLayerSub(Identifier &)
Definition: LArDigitRetriever.cxx:494
CaloCell_Base_ID::is_em
bool is_em(const Identifier id) const
test if the id belongs to LArEM
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1963
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
Index
IndexedConstituentUserInfo::Index Index
Definition: IndexedConstituentUserInfo.cxx:12
AthCommonDataStore
Definition: AthCommonDataStore.h:52
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
JiveXML::LArDigitRetriever::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArDigitRetriever.h:79
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloCell_Base_ID::is_fcal
bool is_fcal(const Identifier id) const
test if the id belongs to the FCAL - true also for MiniFCAL
DetDescrDictionaryDict::it1
std::vector< HWIdentifier >::iterator it1
Definition: DetDescrDictionaryDict.h:17
JiveXML::LArDigitRetriever::getLArDigitData
const DataMap getLArDigitData(const CaloCellContainer *cellContainer, const std::string &datatype, CaloCell_ID::SUBCALO calotype)
Retrieve Tile cell location and details.
Definition: LArDigitRetriever.cxx:123
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
test_pyathena.parent
parent
Definition: test_pyathena.py:15
JiveXML::LArDigitRetriever::m_sub
DataVect m_sub
Definition: LArDigitRetriever.h:102
JiveXML::LArDigitRetriever::m_cellEnergyPrec
int m_cellEnergyPrec
Definition: LArDigitRetriever.h:95
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
WriteCellNoiseToCool.cellGain
cellGain
Definition: WriteCellNoiseToCool.py:434
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.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
JiveXML::LArDigitRetriever::calcEMLayerSub
void calcEMLayerSub(Identifier &)
Definition: LArDigitRetriever.cxx:484
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
JiveXML::LArDigitRetriever::m_inputdpd
bool m_inputdpd
Definition: LArDigitRetriever.h:94
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
JiveXML::LArDigitRetriever::m_adc2mevKey
SG::ReadCondHandleKey< LArADC2MeV > m_adc2mevKey
Definition: LArDigitRetriever.h:82
calibdata.datatypes
list datatypes
Definition: calibdata.py:55
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArOnlineID
Definition: LArOnlineID.h:20
JiveXML::LArDigitRetriever::m_doLArDigit
bool m_doLArDigit
Definition: LArDigitRetriever.h:89
LArNewCalib_Delay_OFC_Cali.FT
FT
Definition: LArNewCalib_Delay_OFC_Cali.py:123
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
JiveXML::LArDigitRetriever::retrieve
virtual StatusCode retrieve(ToolHandle< IFormatTool > &FormatTool)
Retrieve all the data.
Definition: LArDigitRetriever.cxx:81
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1944
a
TList * a
Definition: liststreamerinfos.cxx:10
y
#define y
h
JiveXML::LArDigitRetriever::m_doMaskLArChannelsM5
bool m_doMaskLArChannelsM5
Definition: LArDigitRetriever.h:100
CaloDetDescrElement::dx
float dx() const
cell dx
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:375
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
JiveXML::LArDigitRetriever::m_LArChannelsToIgnoreM5
std::vector< Identifier::value_type > m_LArChannelsToIgnoreM5
Definition: LArDigitRetriever.h:99
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
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
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
JiveXML::LArDigitRetriever::m_cellConditionCut
bool m_cellConditionCut
Definition: LArDigitRetriever.h:93
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
JiveXML::LArDigitRetriever::m_sgKeyLArDigit_raw
SG::ReadHandleKey< LArDigitContainer > m_sgKeyLArDigit_raw
Definition: LArDigitRetriever.h:77
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::LArDigitRetriever::m_lar
bool m_lar
Definition: LArDigitRetriever.h:86
CaloCell_Base_ID::LAREM
@ LAREM
Definition: CaloCell_Base_ID.h:46
dqBeamSpot.nEntries
int nEntries
Definition: dqBeamSpot.py:73
CaloDetDescrElement::dy
float dy() const
cell dy
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:377
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
fitman.k
k
Definition: fitman.py:528
LArVectorProxy
Proxy for accessing a range of float values like a vector.
Definition: LArVectorProxy.h:38
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
python.LArCondContChannels.posNeg
posNeg
Definition: LArCondContChannels.py:659
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 22:16:46 for ATLAS Offline Software by   doxygen 1.8.18