ATLAS Offline Software
egammaForwardBuilder.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "egammaForwardBuilder.h"
15 
18 #include "xAODEgamma/Electron.h"
19 
21 #include "PATCore/AcceptData.h"
22 
23 #include "FourMomUtils/P4Helpers.h"
24 
25 #include <algorithm>
26 #include <cmath>
27 
28 namespace {
29  constexpr float cellEtaSize = 0.1;
30  constexpr float cellPhiSize = 0.1;
31 
32  template <typename... T>
33  void copyMoments(const xAOD::CaloCluster& src,
34  std::unique_ptr<xAOD::CaloCluster>& dest,
35  T... momentIds) {
36  for (const auto& momentId : {momentIds...}) {
37  double moment {};
38  src.retrieveMoment(momentId, moment);
39  dest->insertMoment(momentId, moment);
40  }
41  }
42 }
43 
45  ISvcLocator* pSvcLocator)
46  : AthReentrantAlgorithm(name, pSvcLocator)
47 {}
48 
50 {
51  m_maxDelPhi = m_maxDelPhiCells * cellPhiSize * 0.5;
52  m_maxDelEta = m_maxDelEtaCells * cellEtaSize * 0.5;
53  m_maxDelR2 = m_maxDelR * m_maxDelR; // Square now to avoid a slow sqrt later.
54 
55  // The data handle keys.
62 
63  // Retrieve object quality tool.
64  if (!m_objectQualityTool.empty()) {
65  ATH_CHECK(m_objectQualityTool.retrieve());
66  }
67 
68  else {
69  m_objectQualityTool.disable();
70  }
71 
73 
74  if (
77  ) {
79  "Number of selectors doesn't match number of given fwd-electron selector names"
80  );
81 
82  return StatusCode::FAILURE;
83  }
84 
85  // Retrieve track match builder.
87 
88  ATH_MSG_DEBUG("Initialization completed successfully");
89 
90  return StatusCode::SUCCESS;
91 }
92 
94 {
95 
96  ATH_MSG_INFO("====> Forward Egamma Statistics =============");
97  ATH_MSG_INFO(" All Clusters " << m_AllClusters);
98  ATH_MSG_INFO(" Matched Clusters " << m_MatchedClusters);
99  ATH_MSG_INFO("=============================================");
100 
101  return StatusCode::SUCCESS;
102 }
103 
104 StatusCode egammaForwardBuilder::execute(const EventContext& ctx) const
105 {
106  // Create an egamma container and register it.
108  ATH_CHECK(xaodFrwd.record(
109  std::make_unique<xAOD::ElectronContainer>(),
110  std::make_unique<xAOD::ElectronAuxContainer>())
111  );
112 
113  // Create the relevant cluster output and register it.
116  ctx
117  );
118 
120  SG::WriteHandle<CaloClusterCellLinkContainer> outClusterContainerCellLink(
122  ctx
123  );
124 
125  ATH_CHECK(outClusterContainerCellLink.record(
126  std::make_unique<CaloClusterCellLinkContainer>())
127  );
128 
129  // Topo cluster container.
131 
132  // Check is only used for serial running, remove when MT scheduler used.
133  ATH_CHECK(inputClusters.isValid());
134 
135  // Calorimeter description.
136  SG::ReadCondHandle<CaloDetDescrManager> caloDetDescrMgrHandle{
138  };
139  ATH_CHECK(caloDetDescrMgrHandle.isValid());
140  const CaloDetDescrManager* calodetdescrmgr = *caloDetDescrMgrHandle;
141 
142  static const SG::AuxElement::Accessor<
143  std::vector<ElementLink<xAOD::CaloClusterContainer>>
144  > caloClusterLinks("constituentClusterLinks");
145 
146  // Prepare to create clusters.
147  EgammaRecContainer egammaRecsFwd;
148  size_t origClusterIndex = 0;
149 
150  // Loop over input cluster container and create egRecs to store the electrons.
151  for (const xAOD::CaloCluster* cluster : *inputClusters) {
152 
153  // Create links back to the original clusters.
154  std::vector<ElementLink<xAOD::CaloClusterContainer>> constituentLinks;
155 
156  // The constituent links should contain a CaloCal cluster. When not running
157  // in ITk mode this is the default for the forward clusters used by egamma
158  // so no sister link is needed to get the CaloCal. When running in ITk mode
159  // the clusters used are CaloTopoClusters so need to access the sister
160  // cluster to maintain consistency.
161  if (m_doTrackMatching) {
163  cluster->getSisterClusterLink();
164 
165  if (sisterCluster) {
166  constituentLinks.push_back(sisterCluster);
167  } else {
168  ATH_MSG_WARNING("No sister Link available");
169  }
170  } else {
171  constituentLinks.emplace_back(*inputClusters, origClusterIndex, ctx);
172  }
173 
174  const DataLink<CaloCellContainer>& cellCont =
175  cluster->getCellLinks()->getCellContainerLink();
176 
177  // Create the new cluster.
178  std::unique_ptr<xAOD::CaloCluster> newCluster =
180  cookieCut(*cluster, *calodetdescrmgr, cellCont) :
181  std::make_unique<xAOD::CaloCluster>(*cluster);
182 
183  if (!newCluster) {
184  continue;
185  }
186 
187  caloClusterLinks(*newCluster) = constituentLinks;
188  outClusterContainer->push_back(std::move(newCluster));
189 
190  size_t index = outClusterContainer->size() - 1;
191  const ElementLink<xAOD::CaloClusterContainer> clusterLink(*outClusterContainer, index, ctx);
192  const std::vector<ElementLink<xAOD::CaloClusterContainer>> clusterLinkVector{clusterLink};
193 
194  // Now create the egamma Rec
195  egammaRecsFwd.push_back(std::make_unique<egammaRec>(clusterLinkVector));
196 
197  ++origClusterIndex;
198  }
199 
200  // Add track-cluster matching information if requested.
201  if (m_doTrackMatching) {
202  ATH_CHECK(m_trackMatchBuilder->executeRec(ctx, &egammaRecsFwd));
203  }
204 
205  auto buff_AllClusters = m_AllClusters.buffer();
206  auto buff_MatchedClusters = m_MatchedClusters.buffer();
207 
208  //Loop over the egamma Rec creating electrons
209  for (const egammaRec* egRec : egammaRecsFwd) {
210  if (!egRec) {
211  return StatusCode::FAILURE;
212  }
213 
214  ++buff_AllClusters;
215 
216  if (m_doTrackMatching && egRec->getNumberOfTrackParticles() == 0) {
217  // Later we may want to use these for so called forward photons.
218  ATH_MSG_DEBUG("EgammaRec without track particle");
219  continue;
220  }
221 
222  //common part
223  xAOD::Electron* el = xaodFrwd->push_back(std::make_unique<xAOD::Electron>());
225  el->setCaloClusterLinks(egRec->caloClusterElementLinks());
226 
227  // from here one, we need both track matching and
228  // having tracks .
229  if (m_doTrackMatching) {
230 
231  ++buff_MatchedClusters;
232  el->setTrackParticleLinks(egRec->trackParticleElementLinks());
233 
234  const xAOD::TrackParticle* trackParticle = el->trackParticle();
235  if (trackParticle) {
236  el->setCharge(trackParticle->charge());
237  } else {
238  ATH_MSG_WARNING("Forward electron without track particle, whereas"
239  " corresponding egammaRec has at least one");
240  }
241 
242  // Set DeltaEta, DeltaPhi, DeltaPhiRescaled.
243  el->setTrackCaloMatchValues(
244  egRec->deltaEta(),
245  egRec->deltaPhi(),
246  egRec->deltaPhiRescaled(),
247  egRec->deltaPhiLast()
248  );
249  }
250 
253 
254  // Apply the Forward Electron selectors.
255  for (size_t i = 0; i < m_forwardElectronIsEMSelectors.size(); ++i) {
258 
259  // Save the bool result.
260  const asg::AcceptData accept = selector->accept(ctx, el);
261  el->setPassSelection(static_cast<bool>(accept), name);
262 
263  // Save the isem.
264  el->setSelectionisEM(accept.getCutResultInverted(), "isEM" + name);
265  }
266 
267  }//end of loop over egammaRecs
268 
270  ctx,
271  outClusterContainer,
272  outClusterContainerCellLink);
273 
274  return StatusCode::SUCCESS;
275 }
276 
279  const EventContext& ctx,
281 ) const {
282  // Protection in case tool is not available return success as algorithm can run without it.
283  if (!m_objectQualityTool.isEnabled()) { return StatusCode::SUCCESS; }
284 
285  return m_objectQualityTool->execute(ctx,*eg);
286 }
287 
290 {
291  if (!m_doTrackMatching) {
292  m_trackMatchBuilder.disable();
293  return StatusCode::SUCCESS;
294  }
295 
296  if (m_trackMatchBuilder.empty()) {
297  ATH_MSG_ERROR("EMTrackMatchBuilder is empty, but track matching is enabled");
298  return StatusCode::FAILURE;
299  }
300 
301  if (m_trackMatchBuilder.retrieve().isFailure()) {
302  ATH_MSG_ERROR("Unable to retrieve " << m_trackMatchBuilder);
303  return StatusCode::FAILURE;
304  }
305 
306  return StatusCode::SUCCESS;
307 }
308 
309 std::unique_ptr<xAOD::CaloCluster> egammaForwardBuilder::cookieCut(
310  const xAOD::CaloCluster& cluster,
311  const CaloDetDescrManager& mgr,
312  const DataLink<CaloCellContainer>& cellCont
313 ) const {
314  if (!cluster.hasSampling(CaloSampling::EME2) &&
315  !cluster.hasSampling(CaloSampling::FCAL0)) {
316  return nullptr;
317  }
318 
319  CookieCutterHelpers::CentralPosition cp0({&cluster}, mgr);
320 
321  const bool isEC = cp0.emaxEC >= cp0.emaxF;
322  const float eta = isEC ? cp0.etaEC : cp0.etaF;
323  const float phi = isEC ? cp0.phiEC : cp0.phiF;
324 
325  auto newCluster = CaloClusterStoreHelper::makeCluster(cellCont);
326 
327 
328  if (!newCluster) {
329  ATH_MSG_ERROR("CaloClusterStoreHelper::makeCluster failed.");
330  return nullptr;
331  }
332 
333  CaloClusterCellLink* newCellLinks = newCluster->getOwnCellLinks();
334  copyMoments(cluster,
335  newCluster,
344 
345  const CaloClusterCellLink* cellLinks = cluster.getCellLinks();
346  CaloClusterCellLink::const_iterator cellItr = cellLinks->begin();
347  CaloClusterCellLink::const_iterator cellEnd = cellLinks->end();
348 
349  for (; cellItr != cellEnd; ++cellItr) {
350  const float deltaEta = std::abs(eta - cellItr->eta());
351  const float deltaPhi = std::abs(P4Helpers::deltaPhi(phi, cellItr->phi()));
352 
353  const float deltaEta2 = deltaEta * deltaEta;
354  const float deltaPhi2 = deltaPhi * deltaPhi;
355 
356  const bool excludeCell = isEC ?
359 
360  if (!excludeCell) {
361  newCellLinks->addCell(cellItr.index(), cellItr.weight());
362  }
363  }
364 
365  CaloClusterKineHelper::calculateKine(newCluster.get(), true, true);
366 
367  return newCluster;
368 }
369 
CaloClusterStoreHelper::makeCluster
static std::unique_ptr< xAOD::CaloCluster > makeCluster(const CaloCellContainer *cellCont)
Creates a valid CaloCluster with a private Aux-Store and CellLink container.
Definition: CaloClusterStoreHelper.cxx:13
xAOD::CaloCluster_v1::SECOND_R
@ SECOND_R
Second Moment in .
Definition: CaloCluster_v1.h:123
egammaForwardBuilder::m_maxDelEta
float m_maxDelEta
Definition: egammaForwardBuilder.h:183
CookieCutterHelpers::CentralPosition
Find the reference position (eta, phi) relative to which cells are restricted.
Definition: CookieCutterHelpers.h:19
CaloClusterKineHelper.h
CaloClusterStoreHelper::finalizeClusters
static StatusCode finalizeClusters(SG::WriteHandle< CaloClusterCellLinkContainer > &h, xAOD::CaloClusterContainer *pClusterColl)
Finalize clusters (move CaloClusterCellLink to a separate container).
Definition: CaloClusterStoreHelper.cxx:64
CaloCell::phi
virtual double phi() const override final
get phi (through CaloDetDescrElement)
Definition: CaloCell.h:359
IAsgForwardElectronIsEMSelector.h
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloClusterStoreHelper::AddContainerWriteHandle
static StatusCode AddContainerWriteHandle(SG::WriteHandle< xAOD::CaloClusterContainer > &clusColl)
Creates a new xAOD::CaloClusterContainer in the given WriteHandle + CaloClusterAuxContainer and recor...
Definition: CaloClusterStoreHelper.cxx:53
ParticleTest.eg
eg
Definition: ParticleTest.py:29
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
WriteCellNoiseToCool.src
src
Definition: WriteCellNoiseToCool.py:513
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:150
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
egammaForwardBuilder::m_forwardElectronIsEMSelectors
ToolHandleArray< IAsgForwardElectronIsEMSelector > m_forwardElectronIsEMSelectors
Handle to the selectors.
Definition: egammaForwardBuilder.h:189
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:160
egammaForwardBuilder::egammaForwardBuilder
egammaForwardBuilder(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: egammaForwardBuilder.cxx:44
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
egammaForwardBuilder::m_AllClusters
Gaudi::Accumulators::Counter m_AllClusters
Definition: egammaForwardBuilder.h:180
xAOD::EgammaParameters::deltaEta2
@ deltaEta2
difference between the cluster eta (second sampling) and the eta of the track extrapolated to the sec...
Definition: EgammaEnums.h:187
egammaForwardBuilder::m_doCookieCutting
Gaudi::Property< bool > m_doCookieCutting
Private member flag to do cookie cutting.
Definition: egammaForwardBuilder.h:149
xAOD::CaloCluster_v1::CENTER_LAMBDA
@ CENTER_LAMBDA
Shower depth at Cluster Centroid.
Definition: CaloCluster_v1.h:136
perfmonmt-printer.dest
dest
Definition: perfmonmt-printer.py:189
egammaForwardBuilder::RetrieveEMTrackMatchBuilder
StatusCode RetrieveEMTrackMatchBuilder()
Definition: egammaForwardBuilder.cxx:289
xAOD::Egamma_v1
Definition: Egamma_v1.h:56
egammaForwardBuilder::ExecObjectQualityTool
StatusCode ExecObjectQualityTool(const EventContext &ctx, xAOD::Egamma *eg) const
Definition: egammaForwardBuilder.cxx:278
xAOD::EgammaParameters::AuthorFwdElectron
const uint16_t AuthorFwdElectron
Electron reconstructed by the Forward cluster-based algorithm.
Definition: EgammaDefs.h:30
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
egammaForwardBuilder::m_forwardElectronIsEMSelectorResultNames
Gaudi::Property< std::vector< std::string > > m_forwardElectronIsEMSelectorResultNames
Definition: egammaForwardBuilder.h:196
CaloClusterAuxContainer.h
xAOD::CaloCluster_v1::ENG_FRAC_MAX
@ ENG_FRAC_MAX
Energy fraction of hottest cell.
Definition: CaloCluster_v1.h:140
CaloDetDescrManager.h
Definition of CaloDetDescrManager.
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:83
xAOD::CaloCluster_v1::SECOND_LAMBDA
@ SECOND_LAMBDA
Second Moment in .
Definition: CaloCluster_v1.h:124
egammaForwardBuilder::m_maxDelR
Gaudi::Property< float > m_maxDelR
Size of cone to cookie cut on FCal.
Definition: egammaForwardBuilder.h:173
BchCleanup.mgr
mgr
Definition: BchCleanup.py:294
egammaForwardBuilder::m_outClusterContainerCellLinkKey
SG::WriteHandleKey< CaloClusterCellLinkContainer > m_outClusterContainerCellLinkKey
Output cluster container cell links: name taken from containter name.
Definition: egammaForwardBuilder.h:138
xAOD::CaloCluster_v1::SECOND_ENG_DENS
@ SECOND_ENG_DENS
Second Moment in E/V.
Definition: CaloCluster_v1.h:144
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
P4Helpers::deltaPhi
double deltaPhi(double phiA, double phiB)
delta Phi in range [-pi,pi[
Definition: P4Helpers.h:34
egammaForwardBuilder::initialize
virtual StatusCode initialize() override final
Initialize method.
Definition: egammaForwardBuilder.cxx:49
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ElectronContainer.h
P4Helpers::deltaEta
double deltaEta(const I4Momentum &p1, const I4Momentum &p2)
Computes efficiently .
Definition: P4Helpers.h:66
egammaForwardBuilder::execute
virtual StatusCode execute(const EventContext &ctx) const override final
Execute method.
Definition: egammaForwardBuilder.cxx:104
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloCluster.h
ElectronAuxContainer.h
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
egammaForwardBuilder::m_doTrackMatching
Gaudi::Property< bool > m_doTrackMatching
Private member flag to do the track matching.
Definition: egammaForwardBuilder.h:141
egammaForwardBuilder::m_maxDelPhiCells
Gaudi::Property< int > m_maxDelPhiCells
Size of maximum search window in phi.
Definition: egammaForwardBuilder.h:165
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
EMFourMomBuilder.h
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
AcceptData.h
xAOD::CaloCluster_v1::getCellLinks
const CaloClusterCellLink * getCellLinks() const
Get a pointer to the CaloClusterCellLink object (const version)
Definition: CaloCluster_v1.cxx:905
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
P4Helpers.h
egammaForwardBuilder::m_outClusterContainerKey
SG::WriteHandleKey< xAOD::CaloClusterContainer > m_outClusterContainerKey
Output cluster container.
Definition: egammaForwardBuilder.h:130
egammaForwardBuilder.h
egammaForwardBuilder::finalize
virtual StatusCode finalize() override final
Finalize method.
Definition: egammaForwardBuilder.cxx:93
EMFourMomBuilder::calculate
void calculate(xAOD::Electron &electron)
Definition: EMFourMomBuilder.cxx:68
CookieCutterHelpers.h
egammaForwardBuilder::m_trackMatchBuilder
ToolHandle< IEMTrackMatchBuilder > m_trackMatchBuilder
Tool to perform track-cluster matching.
Definition: egammaForwardBuilder.h:98
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
IegammaBaseTool.h
xAOD::EgammaParameters::deltaPhi2
@ deltaPhi2
difference between the cluster phi (second sampling) and the phi of the track extrapolated to the sec...
Definition: EgammaEnums.h:204
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
egammaForwardBuilder::cookieCut
std::unique_ptr< xAOD::CaloCluster > cookieCut(const xAOD::CaloCluster &cluster, const CaloDetDescrManager &mgr, const DataLink< CaloCellContainer > &cellCont) const
Remove cells that are too far from the center of mass.
Definition: egammaForwardBuilder.cxx:309
xAOD::Electron_v1
Definition: Electron_v1.h:34
CaloClusterStoreHelper.h
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
python.selector.AtlRunQuerySelectorLhcOlc.selector
selector
Definition: AtlRunQuerySelectorLhcOlc.py:611
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
xAOD::CaloCluster_v1::SIGNIFICANCE
@ SIGNIFICANCE
Cluster significance.
Definition: CaloCluster_v1.h:157
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
egammaForwardBuilder::m_topoClusterKey
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_topoClusterKey
Input topo cluster type.
Definition: egammaForwardBuilder.h:106
CaloClusterContainer.h
CaloClusterKineHelper::calculateKine
static void calculateKine(xAOD::CaloCluster *clu, const bool useweight=true, const bool updateLayers=true, const bool useGPUCriteria=false)
Helper class to calculate cluster kinematics based on cells.
Definition: CaloClusterKineHelper.cxx:223
xAOD::CaloCluster_v1::LATERAL
@ LATERAL
Normalized lateral moment.
Definition: CaloCluster_v1.h:137
egammaRec
Definition: egammaRec.h:31
Electron.h
egammaForwardBuilder::m_caloDetDescrMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloDetDescrMgrKey
Calorimeter description.
Definition: egammaForwardBuilder.h:114
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
xAOD::CaloCluster_v1::hasSampling
bool hasSampling(const CaloSample s) const
Checks if certain smapling contributes to cluster.
Definition: CaloCluster_v1.h:890
asg::AcceptData
Definition: AcceptData.h:30
xAOD::CaloCluster_v1::LONGITUDINAL
@ LONGITUDINAL
Normalized longitudinal moment.
Definition: CaloCluster_v1.h:138
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition: FastCaloSim_CaloCell_ID.h:40
egammaForwardBuilder::m_MatchedClusters
Gaudi::Accumulators::Counter m_MatchedClusters
Definition: egammaForwardBuilder.h:181
egammaForwardBuilder::m_maxDelPhi
float m_maxDelPhi
Definition: egammaForwardBuilder.h:184
egammaForwardBuilder::m_objectQualityTool
ToolHandle< IegammaOQFlagsBuilder > m_objectQualityTool
Tool to perform object quality.
Definition: egammaForwardBuilder.h:90
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
CookieCutterHelpers::CentralPosition::emaxEC
float emaxEC
Definition: CookieCutterHelpers.h:25
egammaForwardBuilder::m_maxDelR2
float m_maxDelR2
Definition: egammaForwardBuilder.h:185
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
CaloCell::eta
virtual double eta() const override final
get eta (through CaloDetDescrElement)
Definition: CaloCell.h:366
egammaForwardBuilder::m_maxDelEtaCells
Gaudi::Property< int > m_maxDelEtaCells
Size of maximum search window in eta.
Definition: egammaForwardBuilder.h:157
egammaForwardBuilder::m_electronOutputKey
SG::WriteHandleKey< xAOD::ElectronContainer > m_electronOutputKey
Output electron container.
Definition: egammaForwardBuilder.h:122