ATLAS Offline Software
Classes | Public Member Functions | Private Member Functions | Private Attributes | List of all members
DerivationFramework::MaxCellDecorator Class Reference

#include <MaxCellDecorator.h>

Inheritance diagram for DerivationFramework::MaxCellDecorator:
Collaboration diagram for DerivationFramework::MaxCellDecorator:

Classes

struct  calculation
 

Public Member Functions

 MaxCellDecorator (const std::string &t, const std::string &n, const IInterface *p)
 
 ~MaxCellDecorator ()
 
StatusCode initialize ()
 
StatusCode finalize ()
 
virtual StatusCode addBranches () const
 

Private Member Functions

calculation decorateObject (const xAOD::CaloCluster *cluster, const EventContext &ctx) const
 

Private Attributes

SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
 
SG::ReadHandleKey< xAOD::EgammaContainer > m_SGKey_photons { this, "SGKey_photons", "", "SG key of photon container" }
 
SG::ReadHandleKey< xAOD::EgammaContainer > m_SGKey_electrons
 
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_SGKey_egammaClusters
 This should be only for using run 2 reprocessing, which misses the cell link from LRT electron clusters : try to get info from the best matched "regular" egamma cluster. More...
 
SG::ReadHandleKey< xAOD::TauJetContainer > m_SGKey_taus { this, "SGKey_taus", "", "SG key of tau container" }
 
SG::ReadHandleKey< xAOD::JetContainer > m_SGKey_jets { this, "SGKey_jets", "", "SG key of jet container" }
 
Gaudi::Property< double > m_dRLRTegClusegClusMax
 matching cone size More...
 
SG::WriteDecorHandleKeyArray< xAOD::EgammaContainer > m_SGKey_photons_decorations
 
SG::WriteDecorHandleKeyArray< xAOD::EgammaContainer > m_SGKey_electrons_decorations
 
SG::WriteDecorHandleKeyArray< xAOD::TauJetContainer > m_SGKey_taus_decorations
 
SG::WriteDecorHandleKeyArray< xAOD::JetContainer > m_SGKey_jets_decorations
 

Detailed Description

Definition at line 30 of file MaxCellDecorator.h.

Constructor & Destructor Documentation

◆ MaxCellDecorator()

DerivationFramework::MaxCellDecorator::MaxCellDecorator ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 18 of file MaxCellDecorator.cxx.

21  : base_class(t, n, p)
22 {
23 }

◆ ~MaxCellDecorator()

DerivationFramework::MaxCellDecorator::~MaxCellDecorator ( )
default

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::MaxCellDecorator::addBranches ( ) const
virtual

Definition at line 118 of file MaxCellDecorator.cxx.

119 {
120  const EventContext& ctx = Gaudi::Hive::currentContext();
121 
122  if (!m_SGKey_photons.key().empty()) {
123  // Retrieve photon container
124  SG::ReadHandle<xAOD::EgammaContainer> photonContainer(m_SGKey_photons, ctx);
125  // setup vector of decorators
126  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationPh0(
127  m_SGKey_photons_decorations[0], ctx);
128  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationPh1(
129  m_SGKey_photons_decorations[1], ctx);
130  SG::WriteDecorHandle<xAOD::EgammaContainer, int> decorationPh2(
131  m_SGKey_photons_decorations[2], ctx);
132  SG::WriteDecorHandle<xAOD::EgammaContainer, uint64_t> decorationPh3(
133  m_SGKey_photons_decorations[3], ctx);
134  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationPh4(
135  m_SGKey_photons_decorations[4], ctx);
136  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationPh5(
137  m_SGKey_photons_decorations[5], ctx);
138  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationPh6(
139  m_SGKey_photons_decorations[6], ctx);
140 
141  const xAOD::EgammaContainer* importedPhotons = photonContainer.ptr();
142  for (const auto* egamma : *importedPhotons) {
143  const xAOD::CaloCluster *cluster = egamma->caloCluster();
144  DerivationFramework::MaxCellDecorator::calculation res =
145  decorateObject(cluster, ctx);
146  decorationPh0(*egamma) = res.maxEcell_time;
147  decorationPh1(*egamma) = res.maxEcell_energy;
148  decorationPh2(*egamma) = res.maxEcell_gain;
149  decorationPh3(*egamma) = res.maxEcell_onlId;
150  decorationPh4(*egamma) = res.maxEcell_x;
151  decorationPh5(*egamma) = res.maxEcell_y;
152  decorationPh6(*egamma) = res.maxEcell_z;
153  }
154  }
155 
156  if (!m_SGKey_electrons.key().empty()) {
157  // Retrieve electron container
158  SG::ReadHandle<xAOD::EgammaContainer> electronContainer(m_SGKey_electrons,
159  ctx);
160 
161  //
162  std::optional<SG::WriteDecorHandle<xAOD::EgammaContainer, float>> odecorationEl7;
163  const xAOD::CaloClusterContainer* egClContainer(nullptr);
164  if (!m_SGKey_egammaClusters.key().empty()) {
165  SG::ReadHandle<xAOD::CaloClusterContainer> egClContainerRH(
166  m_SGKey_egammaClusters, ctx);
167  egClContainer = egClContainerRH.ptr();
168  odecorationEl7.emplace(m_SGKey_electrons_decorations[7], ctx);
169  }
170 
171  // setup vector of decorators
172  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationEl0(
173  m_SGKey_electrons_decorations[0], ctx);
174  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationEl1(
175  m_SGKey_electrons_decorations[1], ctx);
176  SG::WriteDecorHandle<xAOD::EgammaContainer, int> decorationEl2(
177  m_SGKey_electrons_decorations[2], ctx);
178  SG::WriteDecorHandle<xAOD::EgammaContainer, uint64_t> decorationEl3(
179  m_SGKey_electrons_decorations[3], ctx);
180  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationEl4(
181  m_SGKey_electrons_decorations[4], ctx);
182  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationEl5(
183  m_SGKey_electrons_decorations[5], ctx);
184  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decorationEl6(
185  m_SGKey_electrons_decorations[6], ctx);
186 
187  const xAOD::EgammaContainer* importedElectrons = electronContainer.ptr();
188  for (const auto* egamma : *importedElectrons) {
189  const xAOD::CaloCluster *cluster = egamma->caloCluster();
190  if (!m_SGKey_egammaClusters.key().empty()) {
191  double dRMin = 9e9;
192  const xAOD::CaloCluster *matchedCluster(nullptr);
193  for (const auto *clus : *egClContainer) {
194  double dR = clus->p4().DeltaR(cluster->p4());
195  if (dR < dRMin && dR < m_dRLRTegClusegClusMax) {
196  dRMin = dR;
197  matchedCluster = clus;
198  }
199  }
200  cluster = matchedCluster;
201  odecorationEl7.value()(*egamma) = dRMin;
202  }
203  DerivationFramework::MaxCellDecorator::calculation res =
204  decorateObject(cluster, ctx);
205  decorationEl0(*egamma) = res.maxEcell_time;
206  decorationEl1(*egamma) = res.maxEcell_energy;
207  decorationEl2(*egamma) = res.maxEcell_gain;
208  decorationEl3(*egamma) = res.maxEcell_onlId;
209  decorationEl4(*egamma) = res.maxEcell_x;
210  decorationEl5(*egamma) = res.maxEcell_y;
211  decorationEl6(*egamma) = res.maxEcell_z;
212  }
213  }
214 
215  if (!m_SGKey_taus.key().empty()) {
216  // Retrieve tau container
217  SG::ReadHandle<xAOD::TauJetContainer> tauJetContainer(m_SGKey_taus, ctx);
218  // setup vector of decorators
219  SG::WriteDecorHandle<xAOD::TauJetContainer, float> decorationTau0(
220  m_SGKey_taus_decorations[0], ctx);
221  SG::WriteDecorHandle<xAOD::TauJetContainer, float> decorationTau1(
222  m_SGKey_taus_decorations[1], ctx);
223  SG::WriteDecorHandle<xAOD::TauJetContainer, int> decorationTau2(
224  m_SGKey_taus_decorations[2], ctx);
225  SG::WriteDecorHandle<xAOD::TauJetContainer, uint64_t> decorationTau3(
226  m_SGKey_taus_decorations[3], ctx);
227  SG::WriteDecorHandle<xAOD::TauJetContainer, float> decorationTau4(
228  m_SGKey_taus_decorations[4], ctx);
229  SG::WriteDecorHandle<xAOD::TauJetContainer, float> decorationTau5(
230  m_SGKey_taus_decorations[5], ctx);
231  SG::WriteDecorHandle<xAOD::TauJetContainer, float> decorationTau6(
232  m_SGKey_taus_decorations[6], ctx);
233 
234  const xAOD::TauJetContainer* importedTaus = tauJetContainer.ptr();
235  for (const auto* tau : *importedTaus) {
236  DerivationFramework::MaxCellDecorator::calculation res;
237  res.maxEcell_energy = -9999.;
238  for (size_t i = 0;i<tau->nClusters();++i) {
239  // get particle
240  const xAOD::IParticle* part = tau->cluster(i);
241  if ( not part ) {
242  ATH_MSG_WARNING("Tau particle link invalid");
243  continue;
244  }
245 
246  const xAOD::CaloCluster* cluster=dynamic_cast<const xAOD::CaloCluster*> (part);
247  if ( not cluster ) {
248  ATH_MSG_WARNING("Tau cluster link invalid");
249  continue;
250  }
251 
252  DerivationFramework::MaxCellDecorator::calculation resCand =
253  decorateObject(cluster, ctx);
254  if (resCand.maxEcell_energy > res.maxEcell_energy) {
255  res = resCand;
256  }
257  }
258 
259  decorationTau0(*tau) = res.maxEcell_time;
260  decorationTau1(*tau) = res.maxEcell_energy;
261  decorationTau2(*tau) = res.maxEcell_gain;
262  decorationTau3(*tau) = res.maxEcell_onlId;
263  decorationTau4(*tau) = res.maxEcell_x;
264  decorationTau5(*tau) = res.maxEcell_y;
265  decorationTau6(*tau) = res.maxEcell_z;
266  }
267  }
268 
269  if (!m_SGKey_jets.key().empty()) {
270  // Retrieve jet container
271  SG::ReadHandle<xAOD::JetContainer> jetContainer(m_SGKey_jets, ctx);
272  // setup vector of decorators
273  SG::WriteDecorHandle<xAOD::JetContainer, float> decorationJet0(
274  m_SGKey_jets_decorations[0], ctx);
275  SG::WriteDecorHandle<xAOD::JetContainer, float> decorationJet1(
276  m_SGKey_jets_decorations[1], ctx);
277  SG::WriteDecorHandle<xAOD::JetContainer, int> decorationJet2(
278  m_SGKey_jets_decorations[2], ctx);
279  SG::WriteDecorHandle<xAOD::JetContainer, uint64_t> decorationJet3(
280  m_SGKey_jets_decorations[3], ctx);
281  SG::WriteDecorHandle<xAOD::JetContainer, float> decorationJet4(
282  m_SGKey_jets_decorations[4], ctx);
283  SG::WriteDecorHandle<xAOD::JetContainer, float> decorationJet5(
284  m_SGKey_jets_decorations[5], ctx);
285  SG::WriteDecorHandle<xAOD::JetContainer, float> decorationJet6(
286  m_SGKey_jets_decorations[6], ctx);
287 
288  const xAOD::JetContainer* importedJets = jetContainer.ptr();
289  for (const auto* jet : *importedJets) {
290  DerivationFramework::MaxCellDecorator::calculation res;
291  res.maxEcell_energy = -9999.;
292  std::vector<const xAOD::CaloCluster*> clusterList;
293  clusterList.clear();
294  for (auto part : jet->getConstituents()) {
295  // get particle
296  if ( not part ) {
297  ATH_MSG_WARNING("Jet particle link invalid");
298  continue;
299  }
300 
301  const xAOD::CaloCluster* cluster=dynamic_cast<const xAOD::CaloCluster*> (part->rawConstituent());
302  if ( cluster) {
303  clusterList.push_back(cluster);
304  } else {
305  const xAOD::IParticle* ipart = dynamic_cast<const xAOD::IParticle*> (part->rawConstituent());
306  if ( ipart ) {
307  const xAOD::PFO* iPFO = dynamic_cast<const xAOD::PFO*>(ipart);
308  if ( iPFO ) {
309  for (unsigned int cidx=0;cidx<iPFO->nCaloCluster();++cidx) {
310  if ( iPFO->cluster(cidx) ) {
311  clusterList.push_back(iPFO->cluster(cidx));
312  }
313  }
314  }
315  }
316  }
317  }
318 
319  for (auto cluster : clusterList) {
320  DerivationFramework::MaxCellDecorator::calculation resCand =
321  decorateObject(cluster, ctx);
322  if (resCand.maxEcell_energy > res.maxEcell_energy) {
323  res = resCand;
324  }
325  }
326 
327  decorationJet0(*jet) = res.maxEcell_time;
328  decorationJet1(*jet) = res.maxEcell_energy;
329  decorationJet2(*jet) = res.maxEcell_gain;
330  decorationJet3(*jet) = res.maxEcell_onlId;
331  decorationJet4(*jet) = res.maxEcell_x;
332  decorationJet5(*jet) = res.maxEcell_y;
333  decorationJet6(*jet) = res.maxEcell_z;
334  }
335  }
336 
337  return StatusCode::SUCCESS;
338 }

◆ decorateObject()

DerivationFramework::MaxCellDecorator::calculation DerivationFramework::MaxCellDecorator::decorateObject ( const xAOD::CaloCluster *  cluster,
const EventContext &  ctx 
) const
private

Definition at line 341 of file MaxCellDecorator.cxx.

344 {
345 
346  DerivationFramework::MaxCellDecorator::calculation result;
347 
348  if (cluster) {
349  if (!cluster->getCellLinks()) {
350  ATH_MSG_DEBUG("CellLinks not found");
351  return result;
352  }
353 
354  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{ m_cablingKey, ctx };
355  const LArOnOffIdMapping* cabling{ *cablingHdl };
356  if (!cabling) {
357  ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
358  return result;
359  }
360 
361  float emax = -9999.;
362 
363  const CaloCell* cell_maxE = nullptr;
364  for (const CaloCell* cell : *cluster) {
365  int sampling = cell->caloDDE()->getSampling();
366  if (sampling == CaloCell_ID::EMB2 || sampling == CaloCell_ID::EME2) {
367  if ((cell->provenance() & 0x2000)) {
368  if (cell->energy() > emax) {
369  emax = cell->energy();
370  cell_maxE = cell;
371  }
372  }
373  }
374  }
375 
376  if (cell_maxE) {
377  const CaloDetDescrElement* caloDDEl = cell_maxE->caloDDE();
378  result.maxEcell_time = cell_maxE->time();
379  result.maxEcell_energy = cell_maxE->energy();
380  result.maxEcell_gain = (int)cell_maxE->gain();
381  result.maxEcell_onlId =
382  (uint64_t)(cabling->createSignalChannelID(caloDDEl->identify()))
383  .get_compact();
384  result.maxEcell_x = caloDDEl->x();
385  result.maxEcell_y = caloDDEl->y();
386  result.maxEcell_z = caloDDEl->z();
387  }
388  }
389  return result;
390 }

◆ finalize()

StatusCode DerivationFramework::MaxCellDecorator::finalize ( )

Definition at line 111 of file MaxCellDecorator.cxx.

112 {
113  return StatusCode::SUCCESS;
114 }

◆ initialize()

StatusCode DerivationFramework::MaxCellDecorator::initialize ( )

Definition at line 30 of file MaxCellDecorator.cxx.

31 {
32  ATH_MSG_VERBOSE("initialize() ...");
33 
34  ATH_CHECK(m_cablingKey.initialize());
35 
36  if (!m_SGKey_electrons.key().empty()) {
37  const std::string key = m_SGKey_electrons.key();
38  ATH_MSG_INFO("Using " << key << " for electrons");
39  ATH_CHECK(m_SGKey_electrons.initialize());
40 
41  // setup vector of decorators
42  m_SGKey_electrons_decorations.emplace_back(key + ".maxEcell_time");
43  m_SGKey_electrons_decorations.emplace_back(key + ".maxEcell_energy");
44  m_SGKey_electrons_decorations.emplace_back(key + ".maxEcell_gain");
45  m_SGKey_electrons_decorations.emplace_back(key + ".maxEcell_onlId");
46  m_SGKey_electrons_decorations.emplace_back(key + ".maxEcell_x");
47  m_SGKey_electrons_decorations.emplace_back(key + ".maxEcell_y");
48  m_SGKey_electrons_decorations.emplace_back(key + ".maxEcell_z");
49 
50  if (!m_SGKey_egammaClusters.key().empty()) {
51  ATH_MSG_INFO("Using " << m_SGKey_egammaClusters.key() << " to try to match a cluster to the LRT egamma cluster");
52  ATH_CHECK(m_SGKey_egammaClusters.initialize());
53  m_SGKey_electrons_decorations.emplace_back(key + ".dR");
54  }
55 
56  ATH_CHECK(m_SGKey_electrons_decorations.initialize());
57  }
58 
59  if (!m_SGKey_photons.key().empty()) {
60  const std::string key = m_SGKey_photons.key();
61  ATH_MSG_INFO("Using " << key << " for photons");
62  ATH_CHECK(m_SGKey_photons.initialize());
63 
64  // setup vector of decorators
65  m_SGKey_photons_decorations.emplace_back(key + ".maxEcell_time");
66  m_SGKey_photons_decorations.emplace_back(key + ".maxEcell_energy");
67  m_SGKey_photons_decorations.emplace_back(key + ".maxEcell_gain");
68  m_SGKey_photons_decorations.emplace_back(key + ".maxEcell_onlId");
69  m_SGKey_photons_decorations.emplace_back(key + ".maxEcell_x");
70  m_SGKey_photons_decorations.emplace_back(key + ".maxEcell_y");
71  m_SGKey_photons_decorations.emplace_back(key + ".maxEcell_z");
72  ATH_CHECK(m_SGKey_photons_decorations.initialize());
73  }
74 
75  if (!m_SGKey_taus.key().empty()) {
76  const std::string key = m_SGKey_taus.key();
77  ATH_MSG_INFO("Using " << key << " for taus");
78  ATH_CHECK(m_SGKey_taus.initialize());
79 
80  // setup vector of decorators
81  m_SGKey_taus_decorations.emplace_back(key + ".maxEcell_time");
82  m_SGKey_taus_decorations.emplace_back(key + ".maxEcell_energy");
83  m_SGKey_taus_decorations.emplace_back(key + ".maxEcell_gain");
84  m_SGKey_taus_decorations.emplace_back(key + ".maxEcell_onlId");
85  m_SGKey_taus_decorations.emplace_back(key + ".maxEcell_x");
86  m_SGKey_taus_decorations.emplace_back(key + ".maxEcell_y");
87  m_SGKey_taus_decorations.emplace_back(key + ".maxEcell_z");
88  ATH_CHECK(m_SGKey_taus_decorations.initialize());
89  }
90 
91  if (!m_SGKey_jets.key().empty()) {
92  const std::string key = m_SGKey_jets.key();
93  ATH_MSG_INFO("Using " << key << " for jets");
94  ATH_CHECK(m_SGKey_jets.initialize());
95 
96  // setup vector of decorators
97  m_SGKey_jets_decorations.emplace_back(key + ".maxEcell_time");
98  m_SGKey_jets_decorations.emplace_back(key + ".maxEcell_energy");
99  m_SGKey_jets_decorations.emplace_back(key + ".maxEcell_gain");
100  m_SGKey_jets_decorations.emplace_back(key + ".maxEcell_onlId");
101  m_SGKey_jets_decorations.emplace_back(key + ".maxEcell_x");
102  m_SGKey_jets_decorations.emplace_back(key + ".maxEcell_y");
103  m_SGKey_jets_decorations.emplace_back(key + ".maxEcell_z");
104  ATH_CHECK(m_SGKey_jets_decorations.initialize());
105  }
106 
107  return StatusCode::SUCCESS;
108 }

Member Data Documentation

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> DerivationFramework::MaxCellDecorator::m_cablingKey
private
Initial value:
{
this,
"CablingKey",
"LArOnOffIdMap",
"SG Key of LArOnOffIdMapping object"
}

Definition at line 53 of file MaxCellDecorator.h.

◆ m_dRLRTegClusegClusMax

Gaudi::Property<double> DerivationFramework::MaxCellDecorator::m_dRLRTegClusegClusMax
private
Initial value:
{
this,
"dRLRTegClusegClusMax",
0.05,
"Maximum delta R to match LRT egammaCluster to std egammaCluster"
}

matching cone size

Definition at line 87 of file MaxCellDecorator.h.

◆ m_SGKey_egammaClusters

SG::ReadHandleKey<xAOD::CaloClusterContainer> DerivationFramework::MaxCellDecorator::m_SGKey_egammaClusters
private
Initial value:
{
this,
"SGKey_egammaClusters",
"",
"SG key of cluster container associated to standard egammas"
}

This should be only for using run 2 reprocessing, which misses the cell link from LRT electron clusters : try to get info from the best matched "regular" egamma cluster.

Definition at line 73 of file MaxCellDecorator.h.

◆ m_SGKey_electrons

SG::ReadHandleKey<xAOD::EgammaContainer> DerivationFramework::MaxCellDecorator::m_SGKey_electrons
private
Initial value:
{
this,
"SGKey_electrons",
"",
"SG key of electron container"
}

Definition at line 63 of file MaxCellDecorator.h.

◆ m_SGKey_electrons_decorations

SG::WriteDecorHandleKeyArray<xAOD::EgammaContainer> DerivationFramework::MaxCellDecorator::m_SGKey_electrons_decorations
private
Initial value:
{
this,
"SGKey_electrons_decorations_noConf",
{},
"SG keys for electrons decorations not really configurable"
}

Definition at line 103 of file MaxCellDecorator.h.

◆ m_SGKey_jets

SG::ReadHandleKey<xAOD::JetContainer> DerivationFramework::MaxCellDecorator::m_SGKey_jets { this, "SGKey_jets", "", "SG key of jet container" }
private

Definition at line 84 of file MaxCellDecorator.h.

◆ m_SGKey_jets_decorations

SG::WriteDecorHandleKeyArray<xAOD::JetContainer> DerivationFramework::MaxCellDecorator::m_SGKey_jets_decorations
private
Initial value:
{
this,
"SGKey_jets_decorations_noConf",
{},
"SG keys for jet decorations not really configurable"
}

Definition at line 119 of file MaxCellDecorator.h.

◆ m_SGKey_photons

SG::ReadHandleKey<xAOD::EgammaContainer> DerivationFramework::MaxCellDecorator::m_SGKey_photons { this, "SGKey_photons", "", "SG key of photon container" }
private

Definition at line 61 of file MaxCellDecorator.h.

◆ m_SGKey_photons_decorations

SG::WriteDecorHandleKeyArray<xAOD::EgammaContainer> DerivationFramework::MaxCellDecorator::m_SGKey_photons_decorations
private
Initial value:
{
this,
"SGKey_photons_decorations_noConf",
{},
"SG keys for photon decorations not really configurable"
}

Definition at line 95 of file MaxCellDecorator.h.

◆ m_SGKey_taus

SG::ReadHandleKey<xAOD::TauJetContainer> DerivationFramework::MaxCellDecorator::m_SGKey_taus { this, "SGKey_taus", "", "SG key of tau container" }
private

Definition at line 81 of file MaxCellDecorator.h.

◆ m_SGKey_taus_decorations

SG::WriteDecorHandleKeyArray<xAOD::TauJetContainer> DerivationFramework::MaxCellDecorator::m_SGKey_taus_decorations
private
Initial value:
{
this,
"SGKey_taus_decorations_noConf",
{},
"SG keys for tau decorations not really configurable"
}

Definition at line 111 of file MaxCellDecorator.h.

The documentation for this class was generated from the following files:
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
DerivationFramework::MaxCellDecorator::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: MaxCellDecorator.h:53
electronContainer
xAOD::ElectronContainer * electronContainer
Definition: TrigGlobEffCorrValidation.cxx:187
get_generator_info.result
result
Definition: get_generator_info.py:21
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
DerivationFramework::MaxCellDecorator::m_SGKey_electrons_decorations
SG::WriteDecorHandleKeyArray< xAOD::EgammaContainer > m_SGKey_electrons_decorations
Definition: MaxCellDecorator.h:103
CaloDetDescrElement::y
float y() const
cell y
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:365
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
DerivationFramework::MaxCellDecorator::calculation::maxEcell_energy
float maxEcell_energy
Definition: MaxCellDecorator.h:44
DerivationFramework::MaxCellDecorator::m_SGKey_egammaClusters
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_SGKey_egammaClusters
This should be only for using run 2 reprocessing, which misses the cell link from LRT electron cluste...
Definition: MaxCellDecorator.h:73
DerivationFramework::MaxCellDecorator::m_SGKey_electrons
SG::ReadHandleKey< xAOD::EgammaContainer > m_SGKey_electrons
Definition: MaxCellDecorator.h:63
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
DerivationFramework::MaxCellDecorator::m_dRLRTegClusegClusMax
Gaudi::Property< double > m_dRLRTegClusegClusMax
matching cone size
Definition: MaxCellDecorator.h:87
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
CaloCell::time
float time() const
get time (data member)
Definition: CaloCell.h:352
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
egamma
Definition: egamma.h:58
CaloCell::energy
double energy() const
get energy (data member)
Definition: CaloCell.h:311
DerivationFramework::MaxCellDecorator::calculation
Definition: MaxCellDecorator.h:42
DerivationFramework::MaxCellDecorator::m_SGKey_taus
SG::ReadHandleKey< xAOD::TauJetContainer > m_SGKey_taus
Definition: MaxCellDecorator.h:81
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:63
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::PFO_v1::nCaloCluster
unsigned int nCaloCluster() const
Find out how many CaloCluster are linked.
Definition: PFO_v1.cxx:659
columnar::ContainerId::cluster
@ cluster
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
lumiFormat.i
int i
Definition: lumiFormat.py:85
DerivationFramework::MaxCellDecorator::m_SGKey_jets
SG::ReadHandleKey< xAOD::JetContainer > m_SGKey_jets
Definition: MaxCellDecorator.h:84
DerivationFramework::MaxCellDecorator::m_SGKey_taus_decorations
SG::WriteDecorHandleKeyArray< xAOD::TauJetContainer > m_SGKey_taus_decorations
Definition: MaxCellDecorator.h:111
beamspotman.n
n
Definition: beamspotman.py:731
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloCell::caloDDE
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition: CaloCell.h:305
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:11
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
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
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
photonContainer
xAOD::PhotonContainer * photonContainer
Definition: TrigGlobEffCorrValidation.cxx:189
DerivationFramework::MaxCellDecorator::m_SGKey_photons
SG::ReadHandleKey< xAOD::EgammaContainer > m_SGKey_photons
Definition: MaxCellDecorator.h:61
DerivationFramework::MaxCellDecorator::m_SGKey_jets_decorations
SG::WriteDecorHandleKeyArray< xAOD::JetContainer > m_SGKey_jets_decorations
Definition: MaxCellDecorator.h:119
xAOD::PFO_v1
Class describing a particle flow object.
Definition: PFO_v1.h:35
CaloCell::gain
CaloGain::CaloGain gain() const
get gain (data member )
Definition: CaloCell.h:345
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
CaloDetDescrElement::x
float x() const
cell x
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:363
DerivationFramework::MaxCellDecorator::calculation::maxEcell_time
float maxEcell_time
Definition: MaxCellDecorator.h:43
DerivationFramework::MaxCellDecorator::m_SGKey_photons_decorations
SG::WriteDecorHandleKeyArray< xAOD::EgammaContainer > m_SGKey_photons_decorations
Definition: MaxCellDecorator.h:95
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CaloDetDescrElement::z
float z() const
cell z
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:367
DerivationFramework::MaxCellDecorator::decorateObject
calculation decorateObject(const xAOD::CaloCluster *cluster, const EventContext &ctx) const
Definition: MaxCellDecorator.cxx:341
xAOD::PFO_v1::cluster
const CaloCluster * cluster(unsigned int index) const
Retrieve a const pointer to a CaloCluster.
Definition: PFO_v1.cxx:669
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Thu Apr 24 2025 21:56:02 for ATLAS Offline Software by   doxygen 1.8.18