ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
CaloCellFastCopyTool Class Reference

Concrete tool for coping Calo cells. More...

#include <CaloCellFastCopyTool.h>

Inheritance diagram for CaloCellFastCopyTool:
Collaboration diagram for CaloCellFastCopyTool:

Public Member Functions

 CaloCellFastCopyTool (const std::string &type, const std::string &name, const IInterface *parent)
 AthAlgTool constructor. More...
 
virtual StatusCode initialize () override
 
virtual StatusCode process (CaloCellContainer *theCellContainer, const EventContext &ctx) const override
 
virtual StatusCode process (CaloConstCellContainer *theCellContainer, const EventContext &ctx) const override
 

Private Member Functions

StatusCode viewNotAvoidingDuplicatesFindCellIsFast (const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
 
StatusCode viewAvoidingDuplicatesFindCellIsFast (const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
 
StatusCode viewNotAvoidingDuplicatesFindCellIsNotFast (const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
 
StatusCode viewAvoidingDuplicatesFindCellIsNotFast (const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
 
template<class CONTAINER >
StatusCode cloneNotAvoidingDuplicatesFindCellIsFast (const CaloCellContainer *srcCont, CONTAINER *destCont) const
 
template<class CONTAINER >
StatusCode cloneAvoidingDuplicatesFindCellIsFast (const CaloCellContainer *srcCont, CONTAINER *destCont) const
 
template<class CONTAINER >
StatusCode cloneNotAvoidingDuplicatesFindCellIsNotFast (const CaloCellContainer *srcCont, CONTAINER *destCont) const
 
template<class CONTAINER >
StatusCode cloneAvoidingDuplicatesFindCellIsNotFast (const CaloCellContainer *srcCont, CONTAINER *destCont) const
 
StatusCode dispatchCopy (const CaloCellContainer *srcCont, CaloCellContainer *destCont) const
 
StatusCode dispatchCopyConst (const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
 

Private Attributes

SG::ReadHandleKey< CaloCellContainer > m_srcCellContainerKey
 
bool m_avoidDuplicates
 
bool m_isFindCellFast
 
IdentifierHash m_hashMax
 
const CaloCell_ID * m_caloID
 Pointer to CaloID helper. More...
 
std::vector< std::string > m_acceptedSampleNames
 
std::vector< CaloCell_ID::SUBCALO > m_acceptedCalos
 
std::vector< IdentifierHash > m_acceptedCellHashes
 
std::vector< bool > m_cellsToBeCopied
 

Detailed Description

Concrete tool for coping Calo cells.

CaloCellFastCopyTool to be used by CaloCellMaker algorithms. The tool copies Calo cells from an existing CaloCellContainer to the one processed by the CaloCellMaker algorithm. Properties of the tool: InputName - source cell container (default: "AllCalo") IncludeSamplings - name of CaloSampling to be copied into new CaloCellContainer AvoidDuplicates - indicates if this tool should avoid duplicates in new CaloCellContainer. IsFindCellFast - indicates if source CaloCellContainer find CaloCell fast (i.e. source CaloCellContainer is complete and ordered or has already initialized internal lookUpTable). In this case this tool can be very fast.

Definition at line 52 of file CaloCellFastCopyTool.h.

Constructor & Destructor Documentation

◆ CaloCellFastCopyTool()

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

AthAlgTool constructor.

Definition at line 30 of file CaloCellFastCopyTool.cxx.

32  : base_class(type, name, parent)
33  , m_srcCellContainerKey("AllCalo")
34  , m_avoidDuplicates(false)
35  , m_isFindCellFast(false)
36  , m_caloID(nullptr)
37 {
38  declareProperty("InputName", m_srcCellContainerKey);
39  declareProperty("IncludeSamplings", m_acceptedSampleNames);
40  declareProperty("AvoidDuplicates", m_avoidDuplicates);
41  declareProperty("IsFindCellFast", m_isFindCellFast);
42 }

Member Function Documentation

◆ cloneAvoidingDuplicatesFindCellIsFast()

template<class CONTAINER >
StatusCode CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsFast ( const CaloCellContainer *  srcCont,
CONTAINER *  destCont 
) const
private

Definition at line 246 of file CaloCellFastCopyTool.cxx.

249 {
250 
251  std::vector<bool> notInContainer(m_hashMax, true);
252  CaloCellContainer::const_iterator itCell = destCont->begin();
253  for (; itCell != destCont->end(); ++itCell) {
254  notInContainer[(*itCell)->caloDDE()->calo_hash()] = false;
255  }
256 
257  const CaloCell* cell;
258  std::vector<IdentifierHash>::const_iterator it = m_acceptedCellHashes.begin();
259  for (; it != m_acceptedCellHashes.end(); ++it) {
260  if (notInContainer[*it]) {
261  cell = srcCont->findCell(*it);
262  if (cell) destCont->push_back_fast(cell->clone());
263  }
264  }
265 
266  destCont->resetLookUpTable();
267  return StatusCode::SUCCESS;
268 }

◆ cloneAvoidingDuplicatesFindCellIsNotFast()

template<class CONTAINER >
StatusCode CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsNotFast ( const CaloCellContainer *  srcCont,
CONTAINER *  destCont 
) const
private

Definition at line 292 of file CaloCellFastCopyTool.cxx.

295 {
296  std::vector<bool> notInContainer(m_hashMax, true);
297  CaloCellContainer::const_iterator itCell = destCont->begin();
298  for (; itCell != destCont->end(); ++itCell) {
299  notInContainer[(*itCell)->caloDDE()->calo_hash()] = false;
300  }
301 
302  IdentifierHash cellHash;
303  const CaloCell* cell;
304  CaloCellContainer::const_iterator itSrcCell = srcCont->begin();
305  for (; itSrcCell != srcCont->end(); ++itSrcCell) {
306  cell = (*itSrcCell);
307  cellHash = cell->caloDDE()->calo_hash();
308  if (m_cellsToBeCopied[cellHash] && notInContainer[cellHash])
309  destCont->push_back_fast(cell->clone());
310  }
311 
312  destCont->resetLookUpTable();
313  return StatusCode::SUCCESS;
314 }

◆ cloneNotAvoidingDuplicatesFindCellIsFast()

template<class CONTAINER >
StatusCode CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsFast ( const CaloCellContainer *  srcCont,
CONTAINER *  destCont 
) const
private

Definition at line 229 of file CaloCellFastCopyTool.cxx.

232 {
233  const CaloCell* cell;
234  std::vector<IdentifierHash>::const_iterator it = m_acceptedCellHashes.begin();
235  for (; it != m_acceptedCellHashes.end(); ++it) {
236  cell = srcCont->findCell(*it);
237  if (cell) destCont->push_back_fast(cell->clone());
238  }
239 
240  destCont->resetLookUpTable();
241  return StatusCode::SUCCESS;
242 }

◆ cloneNotAvoidingDuplicatesFindCellIsNotFast()

template<class CONTAINER >
StatusCode CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsNotFast ( const CaloCellContainer *  srcCont,
CONTAINER *  destCont 
) const
private

Definition at line 272 of file CaloCellFastCopyTool.cxx.

275 {
276  IdentifierHash cellHash;
277  const CaloCell* cell;
278  CaloCellContainer::const_iterator itSrcCell = srcCont->begin();
279  for (; itSrcCell != srcCont->end(); ++itSrcCell) {
280  cell = (*itSrcCell);
281  cellHash = cell->caloDDE()->calo_hash();
282  if (m_cellsToBeCopied[cellHash])
283  destCont->push_back_fast(cell->clone());
284  }
285 
286  destCont->resetLookUpTable();
287  return StatusCode::SUCCESS;
288 }

◆ dispatchCopy()

StatusCode CaloCellFastCopyTool::dispatchCopy ( const CaloCellContainer *  srcCont,
CaloCellContainer *  destCont 
) const
private

Definition at line 318 of file CaloCellFastCopyTool.cxx.

320 {
321  using COPY_CELLS = StatusCode (CaloCellFastCopyTool::*)(const CaloCellContainer *, CaloCellContainer *) const;
322 
323  COPY_CELLS copyCells;
324  if (m_isFindCellFast) {
325  if (destCont->ownPolicy() == SG::OWN_ELEMENTS) {
326  copyCells = (m_avoidDuplicates) ?
327  (&CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsFast<CaloCellContainer>) :
328  (&CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsFast<CaloCellContainer>);
329  }
330  else {
331  REPORT_ERROR(StatusCode::FAILURE) << "Can't copy to a non-const view container.";
332  return StatusCode::FAILURE;
333  }
334  }
335  else {
336  if (destCont->ownPolicy() == SG::OWN_ELEMENTS) {
337  copyCells = (m_avoidDuplicates) ?
338  (&CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsNotFast<CaloCellContainer>) :
339  (&CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsNotFast<CaloCellContainer>);
340  }
341  else {
342  REPORT_ERROR(StatusCode::FAILURE) << "Can't copy to a non-const view container.";
343  return StatusCode::FAILURE;
344  }
345  }
346 
347  return (this->*copyCells)(srcCont, destCont);
348 }

◆ dispatchCopyConst()

StatusCode CaloCellFastCopyTool::dispatchCopyConst ( const CaloCellContainer *  srcCont,
CaloConstCellContainer *  destCont 
) const
private

Definition at line 352 of file CaloCellFastCopyTool.cxx.

354 {
355  using COPY_CONST_CELLS = StatusCode (CaloCellFastCopyTool::*)(const CaloCellContainer *, CaloConstCellContainer *) const;
356 
357  COPY_CONST_CELLS copyConstCells;
358  if (m_isFindCellFast) {
359  if (destCont->ownPolicy() == SG::OWN_ELEMENTS) {
360  copyConstCells = (m_avoidDuplicates) ?
361  (&CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsFast<CaloConstCellContainer>) :
362  (&CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsFast<CaloConstCellContainer>);
363  } else {
364  copyConstCells = (m_avoidDuplicates) ?
365  (&CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsFast) :
366  (&CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsFast);
367  }
368  } else {
369  if (destCont->ownPolicy() == SG::OWN_ELEMENTS) {
370  copyConstCells = (m_avoidDuplicates) ?
371  (&CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsNotFast<CaloConstCellContainer>) :
372  (&CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsNotFast<CaloConstCellContainer>);
373  } else {
374  copyConstCells = (m_avoidDuplicates) ?
375  (&CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsNotFast) :
376  (&CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsNotFast);
377  }
378  }
379 
380  return (this->*copyConstCells)(srcCont, destCont);
381 }

◆ initialize()

StatusCode CaloCellFastCopyTool::initialize ( )
overridevirtual

Definition at line 49 of file CaloCellFastCopyTool.cxx.

49  {
50 
51  ATH_MSG_INFO( "In initialize ");
52 
53  ATH_CHECK( detStore()->retrieve(m_caloID));
54  ATH_CHECK(m_srcCellContainerKey.initialize());
55  std::vector<bool> acceptedSamplings(m_caloID->Unknown, false);
56  std::vector<CaloSampling::CaloSample> acceptedSamples;
57 
58  std::vector<std::string>::const_iterator fName = m_acceptedSampleNames.begin();
59  for (; fName != m_acceptedSampleNames.end(); ++fName) {
60  CaloSampling::CaloSample sampInd = CaloSamplingHelper::getSamplingId(*fName);
61  if (sampInd != CaloSampling::Unknown) {
62  acceptedSamplings[sampInd] = true;
63  acceptedSamples.push_back(sampInd);
64  }
65  }
66 
67  CaloSamplingHelper::getCalos(acceptedSamples, m_acceptedCalos);
68 
69  if (msgLvl(MSG::DEBUG)) {
70 
71  msg(MSG::DEBUG) << "Accepted calo samplings: ";
72  std::vector<CaloSampling::CaloSample>::iterator itSampling = acceptedSamples.begin();
73  for (; itSampling < acceptedSamples.end(); ++itSampling) {
74  msg(MSG::DEBUG) << (int) (*itSampling) << "; ";
75  }
76  msg(MSG::DEBUG) << endmsg;
77 
78  msg(MSG::DEBUG) << "Accepted sub calos: ";
79  std::vector<CaloCell_ID::SUBCALO>::iterator itCalo = m_acceptedCalos.begin();
80  for (; itCalo < m_acceptedCalos.end(); ++itCalo) {
81  msg(MSG::DEBUG) << (int) (*itCalo) << "; ";
82  }
83  msg(MSG::DEBUG) << endmsg;
84  }
85 
86  m_hashMax = m_caloID->calo_cell_hash_max();
87  ATH_MSG_DEBUG( "CaloCell hash max: " << m_hashMax);
88 
89  if (m_isFindCellFast) {
90  for (IdentifierHash cellHash = 0; cellHash < m_hashMax; cellHash += 1) {
91  if (acceptedSamplings[m_caloID->calo_sample(cellHash)]) {
92  m_acceptedCellHashes.push_back(cellHash);
93  }
94  }
95  } else {
96  m_cellsToBeCopied.resize(m_hashMax, false);
97  for (IdentifierHash cellHash = 0; cellHash < m_hashMax; cellHash += 1) {
98  if (acceptedSamplings[m_caloID->calo_sample(cellHash)]) {
99  m_cellsToBeCopied[cellHash] = true;
100  }
101  }
102  }
103 
104  ATH_MSG_DEBUG( "Number of accepted hashes: " << m_acceptedCellHashes.size() );
105 
106 
107  return StatusCode::SUCCESS;
108 }

◆ process() [1/2]

StatusCode CaloCellFastCopyTool::process ( CaloCellContainer *  theCellContainer,
const EventContext &  ctx 
) const
overridevirtual

Definition at line 111 of file CaloCellFastCopyTool.cxx.

113 {
114  // Retrieve source cell container
115  SG::ReadHandle<CaloCellContainer> srcCont(m_srcCellContainerKey, ctx);
116 
117  ATH_CHECK( dispatchCopy (srcCont.cptr(), theCont) );
118 
119  std::vector<CaloCell_ID::SUBCALO>::const_iterator it = m_acceptedCalos.begin();
120  for (; it != m_acceptedCalos.end(); ++it) {
121  if (srcCont->hasCalo(*it)) theCont->setHasCalo(*it);
122  }
123 
124  return StatusCode::SUCCESS;
125 }

◆ process() [2/2]

StatusCode CaloCellFastCopyTool::process ( CaloConstCellContainer *  theCellContainer,
const EventContext &  ctx 
) const
overridevirtual

Definition at line 128 of file CaloCellFastCopyTool.cxx.

130 {
131  // Retrieve source cell container
132  SG::ReadHandle<CaloCellContainer> srcCont(m_srcCellContainerKey, ctx);
133 
134  ATH_CHECK( dispatchCopyConst (srcCont.cptr(), theCont) );
135 
136  std::vector<CaloCell_ID::SUBCALO>::const_iterator it = m_acceptedCalos.begin();
137  for (; it != m_acceptedCalos.end(); ++it) {
138  if (srcCont->hasCalo(*it)) theCont->setHasCalo(*it);
139  }
140 
141  return StatusCode::SUCCESS;
142 }

◆ viewAvoidingDuplicatesFindCellIsFast()

StatusCode CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsFast ( const CaloCellContainer *  srcCont,
CaloConstCellContainer *  destCont 
) const
private

Definition at line 161 of file CaloCellFastCopyTool.cxx.

164 {
165  std::vector<bool> notInContainer(m_hashMax, true);
166  CaloCellContainer::const_iterator itCell = destCont->begin();
167  for (; itCell != destCont->end(); ++itCell) {
168  notInContainer[(*itCell)->caloDDE()->calo_hash()] = false;
169  }
170 
171  const CaloCell* cell;
172  std::vector<IdentifierHash>::const_iterator it = m_acceptedCellHashes.begin();
173  for (; it != m_acceptedCellHashes.end(); ++it) {
174  if (notInContainer[*it]) {
175  cell = srcCont->findCell(*it);
176  if (cell) destCont->push_back_fast(cell);
177  }
178  }
179 
180  destCont->resetLookUpTable();
181  return StatusCode::SUCCESS;
182 }

◆ viewAvoidingDuplicatesFindCellIsNotFast()

StatusCode CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsNotFast ( const CaloCellContainer *  srcCont,
CaloConstCellContainer *  destCont 
) const
private

Definition at line 203 of file CaloCellFastCopyTool.cxx.

206 {
207  std::vector<bool> notInContainer(m_hashMax, true);
208  CaloCellContainer::const_iterator itCell = destCont->begin();
209  for (; itCell != destCont->end(); ++itCell) {
210  notInContainer[(*itCell)->caloDDE()->calo_hash()] = false;
211  }
212 
213  IdentifierHash cellHash;
214  const CaloCell* cell;
215  CaloCellContainer::const_iterator itSrcCell = srcCont->begin();
216  for (; itSrcCell != srcCont->end(); ++itSrcCell) {
217  cell = (*itSrcCell);
218  cellHash = cell->caloDDE()->calo_hash();
219  if (m_cellsToBeCopied[cellHash] && notInContainer[cellHash])
220  destCont->push_back_fast(cell);
221  }
222 
223  destCont->resetLookUpTable();
224  return StatusCode::SUCCESS;
225 }

◆ viewNotAvoidingDuplicatesFindCellIsFast()

StatusCode CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsFast ( const CaloCellContainer *  srcCont,
CaloConstCellContainer *  destCont 
) const
private

Definition at line 145 of file CaloCellFastCopyTool.cxx.

148 {
149  const CaloCell* cell;
150  std::vector<IdentifierHash>::const_iterator it = m_acceptedCellHashes.begin();
151  for (; it != m_acceptedCellHashes.end(); ++it) {
152  cell = srcCont->findCell(*it);
153  if (cell) destCont->push_back_fast(cell);
154  }
155 
156  destCont->resetLookUpTable();
157  return StatusCode::SUCCESS;
158 }

◆ viewNotAvoidingDuplicatesFindCellIsNotFast()

StatusCode CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsNotFast ( const CaloCellContainer *  srcCont,
CaloConstCellContainer *  destCont 
) const
private

Definition at line 185 of file CaloCellFastCopyTool.cxx.

188 {
189  IdentifierHash cellHash;
190  const CaloCell* cell;
191  CaloCellContainer::const_iterator itSrcCell = srcCont->begin();
192  for (; itSrcCell != srcCont->end(); ++itSrcCell) {
193  cell = (*itSrcCell);
194  cellHash = cell->caloDDE()->calo_hash();
195  if (m_cellsToBeCopied[cellHash])
196  destCont->push_back_fast(cell);
197  }
198  destCont->resetLookUpTable();
199  return StatusCode::SUCCESS;
200 }

Member Data Documentation

◆ m_acceptedCalos

std::vector<CaloCell_ID::SUBCALO> CaloCellFastCopyTool::m_acceptedCalos
private

Definition at line 106 of file CaloCellFastCopyTool.h.

◆ m_acceptedCellHashes

std::vector<IdentifierHash> CaloCellFastCopyTool::m_acceptedCellHashes
private

Definition at line 109 of file CaloCellFastCopyTool.h.

◆ m_acceptedSampleNames

std::vector<std::string> CaloCellFastCopyTool::m_acceptedSampleNames
private

Definition at line 105 of file CaloCellFastCopyTool.h.

◆ m_avoidDuplicates

bool CaloCellFastCopyTool::m_avoidDuplicates
private

Definition at line 100 of file CaloCellFastCopyTool.h.

◆ m_caloID

const CaloCell_ID* CaloCellFastCopyTool::m_caloID
private

Pointer to CaloID helper.

Definition at line 103 of file CaloCellFastCopyTool.h.

◆ m_cellsToBeCopied

std::vector<bool> CaloCellFastCopyTool::m_cellsToBeCopied
private

Definition at line 110 of file CaloCellFastCopyTool.h.

◆ m_hashMax

IdentifierHash CaloCellFastCopyTool::m_hashMax
private

Definition at line 102 of file CaloCellFastCopyTool.h.

◆ m_isFindCellFast

bool CaloCellFastCopyTool::m_isFindCellFast
private

Definition at line 101 of file CaloCellFastCopyTool.h.

◆ m_srcCellContainerKey

SG::ReadHandleKey<CaloCellContainer> CaloCellFastCopyTool::m_srcCellContainerKey
private

Definition at line 99 of file CaloCellFastCopyTool.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
CaloCellFastCopyTool::m_acceptedCalos
std::vector< CaloCell_ID::SUBCALO > m_acceptedCalos
Definition: CaloCellFastCopyTool.h:106
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
REPORT_ERROR
#define REPORT_ERROR(SC)
Report an error.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:355
CaloCellFastCopyTool::m_isFindCellFast
bool m_isFindCellFast
Definition: CaloCellFastCopyTool.h:101
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloCellFastCopyTool::m_acceptedCellHashes
std::vector< IdentifierHash > m_acceptedCellHashes
Definition: CaloCellFastCopyTool.h:109
CaloCellFastCopyTool::dispatchCopyConst
StatusCode dispatchCopyConst(const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
Definition: CaloCellFastCopyTool.cxx:352
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
CaloCellFastCopyTool::m_srcCellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_srcCellContainerKey
Definition: CaloCellFastCopyTool.h:99
rootconvert.fName
string fName
Definition: rootconvert.py:5
ConstDataVector::end
iterator end() noexcept
Return an iterator pointing past the end of the collection.
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
CaloConstCellContainer::resetLookUpTable
void resetLookUpTable()
reset look up table
skel.it
it
Definition: skel.GENtoEVGEN.py:423
CaloCellFastCopyTool::dispatchCopy
StatusCode dispatchCopy(const CaloCellContainer *srcCont, CaloCellContainer *destCont) const
Definition: CaloCellFastCopyTool.cxx:318
CaloCell_Base_ID::calo_sample
int calo_sample(const Identifier id) const
returns an int taken from Sampling enum and describing the subCalo to which the Id belongs.
Definition: CaloCell_Base_ID.cxx:141
CaloCellFastCopyTool::m_hashMax
IdentifierHash m_hashMax
Definition: CaloCellFastCopyTool.h:102
CaloCellFastCopyTool::m_cellsToBeCopied
std::vector< bool > m_cellsToBeCopied
Definition: CaloCellFastCopyTool.h:110
CaloCellFastCopyTool::m_caloID
const CaloCell_ID * m_caloID
Pointer to CaloID helper.
Definition: CaloCellFastCopyTool.h:103
SG::OWN_ELEMENTS
@ OWN_ELEMENTS
this data object owns its elements
Definition: OwnershipPolicy.h:17
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsNotFast
StatusCode viewAvoidingDuplicatesFindCellIsNotFast(const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
Definition: CaloCellFastCopyTool.cxx:204
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloConstCellContainer::push_back_fast
void push_back_fast(const CaloCell *cell)
reimplementation of push_back to gain speed in readin
CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsFast
StatusCode viewAvoidingDuplicatesFindCellIsFast(const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
Definition: CaloCellFastCopyTool.cxx:162
CaloSamplingHelper::getCalos
static bool getCalos(const std::vector< CaloSampling::CaloSample > &theSamplings, std::vector< CaloCell_ID::SUBCALO > &theCalos)
Returns a list of sub-calos for a list of samplings.
Definition: CaloUtils/src/CaloSamplingHelper.cxx:129
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
WriteCellNoiseToCool.cellHash
cellHash
Definition: WriteCellNoiseToCool.py:433
CaloCellContainer::findCell
const CaloCell * findCell(const IdentifierHash theHash) const
fast find method given identifier hash.
Definition: CaloCellContainer.cxx:345
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsNotFast
StatusCode viewNotAvoidingDuplicatesFindCellIsNotFast(const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
Definition: CaloCellFastCopyTool.cxx:186
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
CaloCellFastCopyTool::m_acceptedSampleNames
std::vector< std::string > m_acceptedSampleNames
Definition: CaloCellFastCopyTool.h:105
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsFast
StatusCode viewNotAvoidingDuplicatesFindCellIsFast(const CaloCellContainer *srcCont, CaloConstCellContainer *destCont) const
Definition: CaloCellFastCopyTool.cxx:146
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
CaloConstCellContainer
CaloCellContainer that can accept const cell pointers.
Definition: CaloConstCellContainer.h:45
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
CaloSamplingHelper::getSamplingId
static CaloSampling::CaloSample getSamplingId(const std::string &samplingName)
Returns the CaloSampling::CaloSample enumerator value.
Definition: CaloUtils/src/CaloSamplingHelper.cxx:61
DEBUG
#define DEBUG
Definition: page_access.h:11
CaloCellFastCopyTool
Concrete tool for coping Calo cells.
Definition: CaloCellFastCopyTool.h:54
DataVector::ownPolicy
SG::OwnershipPolicy ownPolicy() const
Return the ownership policy setting for this container.
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
IdentifierHash
Definition: IdentifierHash.h:38
ConstDataVector::begin
iterator begin() noexcept
Return an iterator pointing at the beginning of the collection.
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
CaloCellFastCopyTool::m_avoidDuplicates
bool m_avoidDuplicates
Definition: CaloCellFastCopyTool.h:100
CaloCell_Base_ID::calo_cell_hash_max
size_type calo_cell_hash_max(void) const
cell 'global' hash table max size
Generated on Thu Jul 4 2024 21:39:33 for ATLAS Offline Software by   doxygen 1.8.18