Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Typedefs | Functions
JetGroupProductFactoryTest.cxx File Reference
#include "gtest/gtest.h"
#include "TrigHLTJetHypo/../src/JetGroupProductFactory.h"
#include <vector>
Include dependency graph for JetGroupProductFactoryTest.cxx:

Go to the source code of this file.

Typedefs

using vec = std::vector< std::size_t >
 

Functions

 TEST (JetGroupProductFactoryTester, nosiblings)
 
 TEST (JetGroupProductFactoryTester, one_clique_fail)
 
 TEST (JetGroupProductFactoryTester, one_clique_pass)
 
 TEST (JetGroupProductFactoryTester, njets_eq_nsiblings)
 
 TEST (JetGroupProductFactoryTester, 3siblings_3jets_pass)
 
 TEST (JetGroupProductFactoryTester, 3siblings_3jets_fail)
 
 TEST (JetGroupProductFactoryTester, dijet_jets_overlap)
 
 TEST (JetGroupProductFactoryTester, dijet_jets_no_overlap)
 
 TEST (JetGroupProductFactoryTester, dijet_jets_some_overlap)
 
 TEST (JetGroupProductFactoryTester, max_jet_0)
 
 TEST (JetGroupProductFactoryTester, max_jet_1)
 
 TEST (JetGroupProductFactoryTester, willpass_fail_0)
 
 TEST (JetGroupProductFactoryTester, willpass_fail_1)
 
 TEST (JetGroupProductFactoryTester, willpass_fail_2)
 
 TEST (JetGroupProductFactoryTester, willpass_pass_0)
 
 TEST (JetGroupProductFactoryTester, willpass_pass_1)
 

Typedef Documentation

◆ vec

using vec = std::vector<std::size_t>

Definition at line 9 of file JetGroupProductFactoryTest.cxx.

Function Documentation

◆ TEST() [1/16]

TEST ( JetGroupProductFactoryTester  ,
3siblings_3jets_fail   
)

Definition at line 222 of file JetGroupProductFactoryTest.cxx.

222  {
223  std::vector<std::size_t> siblings{1, 2, 3};
224 
225 
226  CondInd2JetGroupsInds satisfiedBy;
227  satisfiedBy[0] = std::vector<std::size_t> {};
228  satisfiedBy[1] = std::vector<std::size_t> {0,1,2};
229  satisfiedBy[2] = std::vector<std::size_t> {1};
230  satisfiedBy[3] = std::vector<std::size_t> {1};
231 
232  std::vector<std::size_t> condMult{1u, 1u, 1u, 1u};
233  std::vector<unsigned int> condCap{0, 1, 1, 1};
234  std::vector<int> condClique{-1, 0, 1, 2};
235 
236  JetGroupInd2ElemInds jg2elemjgs;
237  jg2elemjgs[0] = std::vector<std::size_t> {0};
238  jg2elemjgs[1] = std::vector<std::size_t> {1};
239  jg2elemjgs[2] = std::vector<std::size_t> {2};
240 
241  std::size_t parCapacity{0};
242  bool simpleTree{true};
243 
244  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
245 
246  auto jgp = makeJetGroupProduct(siblings,
247  satisfiedBy,
248  condMult,
249  condCap,
250  condClique,
251  jg2elemjgs,
252  parCapacity,
253  simpleTree,
254  collector);
255  EXPECT_TRUE(jgp != nullptr);
256  EXPECT_TRUE(jgp->valid());
257 
258  EXPECT_TRUE(jgp->next(collector).empty());
259  EXPECT_TRUE(jgp->next(collector).empty());
260 }

◆ TEST() [2/16]

TEST ( JetGroupProductFactoryTester  ,
3siblings_3jets_pass   
)

Definition at line 181 of file JetGroupProductFactoryTest.cxx.

181  {
182  std::vector<std::size_t> siblings{1, 2, 3};
183 
184  CondInd2JetGroupsInds satisfiedBy;
185  satisfiedBy[0] = std::vector<std::size_t> {};
186  satisfiedBy[1] = std::vector<std::size_t> {0,1,2};
187  satisfiedBy[2] = std::vector<std::size_t> {0};
188  satisfiedBy[3] = std::vector<std::size_t> {1};
189 
190  std::vector<std::size_t> condMult{1u, 1u, 1u, 1u};
191  std::vector<unsigned int> condCap{0, 1, 1, 1};
192  std::vector<int> condClique{-1, 0, 1, 2};
193 
194  JetGroupInd2ElemInds jg2elemjgs;
195  jg2elemjgs[0] = std::vector<std::size_t> {0};
196  jg2elemjgs[1] = std::vector<std::size_t> {1};
197  jg2elemjgs[2] = std::vector<std::size_t> {2};
198 
199  std::size_t parCapacity{0};
200  bool simpleTree{true};
201 
202  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
203 
204  auto jgp = makeJetGroupProduct(siblings,
205  satisfiedBy,
206  condMult,
207  condCap,
208  condClique,
209  jg2elemjgs,
210  parCapacity,
211  simpleTree,
212  collector);
213  EXPECT_TRUE(jgp != nullptr);
214  EXPECT_TRUE(jgp->valid());
215 
216  vec exp0{0u, 1u, 2u};
217  EXPECT_EQ(jgp->next(collector), exp0);
218  EXPECT_TRUE(jgp->next(collector).empty());
219  EXPECT_TRUE(jgp->next(collector).empty());
220 }

◆ TEST() [3/16]

TEST ( JetGroupProductFactoryTester  ,
dijet_jets_no_overlap   
)

Definition at line 307 of file JetGroupProductFactoryTest.cxx.

307  {
308  std::vector<std::size_t> siblings{1, 2};
309 
310 
311  CondInd2JetGroupsInds satisfiedBy;
312  satisfiedBy[0] = std::vector<std::size_t> {};
313  satisfiedBy[1] = std::vector<std::size_t> {0, 1};
314  satisfiedBy[2] = std::vector<std::size_t> {2, 3};
315 
316  std::vector<std::size_t> condMult{1u, 1u, 1u};
317  std::vector<unsigned int> condCap{2, 1, 1};
318  std::vector<int> condClique{-1, 0, 0};
319 
320  JetGroupInd2ElemInds jg2elemjgs;
321  jg2elemjgs[0] = std::vector<std::size_t> {0};
322  jg2elemjgs[1] = std::vector<std::size_t> {1};
323  jg2elemjgs[2] = std::vector<std::size_t> {2};
324  jg2elemjgs[3] = std::vector<std::size_t> {3};
325 
326  std::size_t parCapacity{2};
327  bool simpleTree{false};
328 
329  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
330 
331  auto jgp = makeJetGroupProduct(siblings,
332  satisfiedBy,
333  condMult,
334  condCap,
335  condClique,
336  jg2elemjgs,
337  parCapacity,
338  simpleTree,
339  collector);
340  EXPECT_TRUE(jgp != nullptr);
341  EXPECT_TRUE(jgp->valid());
342 
343  vec e0{0u, 2u};
344  vec e1{1u, 2u};
345  vec e2{0u, 3u};
346  vec e3{1u, 3u};
347  EXPECT_EQ(jgp->next(collector), e0);
348  EXPECT_EQ(jgp->next(collector), e1);
349  EXPECT_EQ(jgp->next(collector), e2);
350  EXPECT_EQ(jgp->next(collector), e3);
351  EXPECT_TRUE(jgp->next(collector).empty());
352  EXPECT_TRUE(jgp->next(collector).empty());
353 }

◆ TEST() [4/16]

TEST ( JetGroupProductFactoryTester  ,
dijet_jets_overlap   
)

Definition at line 265 of file JetGroupProductFactoryTest.cxx.

265  {
266  std::vector<std::size_t> siblings{1, 2};
267 
268 
269  CondInd2JetGroupsInds satisfiedBy;
270  satisfiedBy[0] = std::vector<std::size_t> {};
271  satisfiedBy[1] = std::vector<std::size_t> {0, 1};
272  satisfiedBy[2] = std::vector<std::size_t> {0, 1};
273 
274  std::vector<std::size_t> condMult{1u, 1u, 1u};
275  std::vector<unsigned int> condCap{2, 1, 1};
276  std::vector<int> condClique{-1, 0, 0};
277 
278  JetGroupInd2ElemInds jg2elemjgs;
279  jg2elemjgs[0] = std::vector<std::size_t> {0};
280  jg2elemjgs[1] = std::vector<std::size_t> {1};
281 
282  std::size_t parCapacity{2};
283  bool simpleTree{false};
284 
285  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
286 
287  auto jgp = makeJetGroupProduct(siblings,
288  satisfiedBy,
289  condMult,
290  condCap,
291  condClique,
292  jg2elemjgs,
293  parCapacity,
294  simpleTree,
295  collector);
296 
297  EXPECT_TRUE(jgp != nullptr);
298  EXPECT_TRUE(jgp->valid());
299 
300  vec e0{0u, 1u};
301  EXPECT_EQ(jgp->next(collector), e0);
302 
303  EXPECT_TRUE(jgp->next(collector).empty());
304  EXPECT_TRUE(jgp->next(collector).empty());
305 }

◆ TEST() [5/16]

TEST ( JetGroupProductFactoryTester  ,
dijet_jets_some_overlap   
)

Definition at line 356 of file JetGroupProductFactoryTest.cxx.

356  {
357  std::vector<std::size_t> siblings{1, 2};
358 
359  CondInd2JetGroupsInds satisfiedBy;
360  satisfiedBy[0] = std::vector<std::size_t> {};
361  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
362  satisfiedBy[2] = std::vector<std::size_t> {2, 3, 4};
363 
364  std::vector<std::size_t> condMult{1u, 1u, 1u};
365  std::vector<unsigned int> condCap{2, 1, 1};
366  std::vector<int> condClique{-1, 0, 0};
367 
368  JetGroupInd2ElemInds jg2elemjgs;
369  jg2elemjgs[0] = std::vector<std::size_t> {0};
370  jg2elemjgs[1] = std::vector<std::size_t> {1};
371  jg2elemjgs[2] = std::vector<std::size_t> {2};
372  jg2elemjgs[3] = std::vector<std::size_t> {3};
373  jg2elemjgs[4] = std::vector<std::size_t> {4};
374 
375  std::size_t parCapacity{2};
376  bool simpleTree{false};
377 
378  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
379 
380  auto jgp = makeJetGroupProduct(siblings,
381  satisfiedBy,
382  condMult,
383  condCap,
384  condClique,
385  jg2elemjgs,
386  parCapacity,
387  simpleTree,
388  collector);
389  EXPECT_TRUE(jgp != nullptr);
390  EXPECT_TRUE(jgp->valid());
391 
392  vec e0{0u, 2u};
393  vec e1{1u, 2u};
394  vec e2{0u, 3u};
395  vec e3{1u, 3u};
396  vec e4{2u, 3u};
397  vec e5{0u, 4u};
398  vec e6{1u, 4u};
399  vec e7{2u, 4u};
400 
401  EXPECT_EQ(jgp->next(collector), e0);
402  EXPECT_EQ(jgp->next(collector), e1);
403  EXPECT_EQ(jgp->next(collector), e2);
404  EXPECT_EQ(jgp->next(collector), e3);
405  EXPECT_EQ(jgp->next(collector), e4);
406  EXPECT_EQ(jgp->next(collector), e5);
407  EXPECT_EQ(jgp->next(collector), e6);
408  EXPECT_EQ(jgp->next(collector), e7);
409 
410  EXPECT_TRUE(jgp->next(collector).empty());
411  EXPECT_TRUE(jgp->next(collector).empty());
412 }

◆ TEST() [6/16]

TEST ( JetGroupProductFactoryTester  ,
max_jet_0   
)

Definition at line 416 of file JetGroupProductFactoryTest.cxx.

416  {
417  CondInd2JetGroupsInds satisfiedBy;
418  satisfiedBy[0] = std::vector<std::size_t> {};
419  satisfiedBy[1] = std::vector<std::size_t> {0};
420  satisfiedBy[2] = std::vector<std::size_t> {0};
421 
422  std::vector<std::size_t> siblings{1, 2};
423 
424  EXPECT_EQ(0u, max_jet(siblings, satisfiedBy));
425 }

◆ TEST() [7/16]

TEST ( JetGroupProductFactoryTester  ,
max_jet_1   
)

Definition at line 427 of file JetGroupProductFactoryTest.cxx.

427  {
428  CondInd2JetGroupsInds satisfiedBy;
429  satisfiedBy[0] = std::vector<std::size_t> {};
430  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
431  satisfiedBy[2] = std::vector<std::size_t> {2, 3, 4};
432 
433  std::vector<std::size_t> siblings{1, 2};
434 
435  EXPECT_EQ(4u, max_jet(siblings, satisfiedBy));
436 }

◆ TEST() [8/16]

TEST ( JetGroupProductFactoryTester  ,
njets_eq_nsiblings   
)

Definition at line 135 of file JetGroupProductFactoryTest.cxx.

135  {
136  std::vector<std::size_t> siblings{1, 2};
137 
138 
139  // just enough jets to pass mono-clique, required = 5+1 = 6 jets
140  CondInd2JetGroupsInds satisfiedBy;
141  satisfiedBy[0] = std::vector<std::size_t> {};
142  satisfiedBy[1] = std::vector<std::size_t> {0,1};
143  satisfiedBy[2] = std::vector<std::size_t> {0,1};
144 
145  std::vector<std::size_t> condMult{1u, 1u, 1u};
146  std::vector<unsigned int> condCap{0, 1, 1};
147  std::vector<int> condClique{-1, 0, 1};
148 
149  JetGroupInd2ElemInds jg2elemjgs;
150  jg2elemjgs[0] = std::vector<std::size_t> {0};
151  jg2elemjgs[1] = std::vector<std::size_t> {1};
152 
153  std::size_t parCapacity{0};
154  bool simpleTree{true};
155 
156  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
157 
158  auto jgp = makeJetGroupProduct(siblings,
159  satisfiedBy,
160  condMult,
161  condCap,
162  condClique,
163  jg2elemjgs,
164  parCapacity,
165  simpleTree,
166  collector);
167 
168 
169  EXPECT_TRUE(jgp != nullptr);
170  EXPECT_TRUE(jgp->valid());
171 
172  vec exp0{0u, 1u};
173  EXPECT_EQ(jgp->next(collector), exp0);
174  EXPECT_TRUE(jgp->next(collector).empty());
175  EXPECT_TRUE(jgp->next(collector).empty());
176 
177 
178 }

◆ TEST() [9/16]

TEST ( JetGroupProductFactoryTester  ,
nosiblings   
)

Definition at line 11 of file JetGroupProductFactoryTest.cxx.

11  {
12  std::vector<std::size_t> siblings{};
13 
14  CondInd2JetGroupsInds satisfiedBy;
15  satisfiedBy[0] = std::vector<std::size_t>();// root node
16 
17  std::vector<std::size_t> condMult{1};
18  std::vector<unsigned int> condCap{0};
19  std::vector<int> condClique{1};
20 
21  JetGroupInd2ElemInds jg2elemjgs;
22 
23  std::size_t parCapacity{0};
24 
25  bool simpleTree{true};
26  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
27 
28  auto jgp = makeJetGroupProduct(siblings,
29  satisfiedBy,
30  condMult,
31  condCap,
32  condClique,
33  jg2elemjgs,
34  parCapacity,
35  simpleTree,
36  collector);
37 
38  EXPECT_TRUE(jgp != nullptr);
39  EXPECT_TRUE(jgp->valid());
40  EXPECT_TRUE(jgp->next(collector).empty());
41 }

◆ TEST() [10/16]

TEST ( JetGroupProductFactoryTester  ,
one_clique_fail   
)

Definition at line 48 of file JetGroupProductFactoryTest.cxx.

48  {
49  std::vector<std::size_t> siblings{1, 2};
50 
51  CondInd2JetGroupsInds satisfiedBy;
52  satisfiedBy[0] = std::vector<std::size_t> {};
53  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
54  satisfiedBy[2] = std::vector<std::size_t> {0, 1, 2};
55 
56  std::vector<std::size_t> condMult{1u, 5u, 1u};
57  std::vector<unsigned int> condCap{0, 1, 1};
58  std::vector<int> condClique{-1, 0, 0};
59 
60  JetGroupInd2ElemInds jg2elemjgs;
61  jg2elemjgs[0] = std::vector<std::size_t> {0};
62  jg2elemjgs[1] = std::vector<std::size_t> {1};
63  jg2elemjgs[2] = std::vector<std::size_t> {2};
64 
65  std::size_t parCapacity{0};
66  bool simpleTree{true};
67 
68  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
69 
70  auto jgp = makeJetGroupProduct(siblings,
71  satisfiedBy,
72  condMult,
73  condCap,
74  condClique,
75  jg2elemjgs,
76  parCapacity,
77  simpleTree,
78  collector);
79 
80 
81  EXPECT_TRUE(jgp != nullptr);
82  EXPECT_TRUE(jgp->valid());
83 
84  EXPECT_TRUE(jgp->next(collector).empty());
85  EXPECT_TRUE(jgp->next(collector).empty());
86 }

◆ TEST() [11/16]

TEST ( JetGroupProductFactoryTester  ,
one_clique_pass   
)

Definition at line 88 of file JetGroupProductFactoryTest.cxx.

88  {
89  std::vector<std::size_t> siblings{1, 2};
90 
91 
92  // just enough jets to pass mono-clique, required = 5+1 = 6 jets
93  CondInd2JetGroupsInds satisfiedBy;
94  satisfiedBy[0] = std::vector<std::size_t> {};
95  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2, 3, 4, 5};
96  satisfiedBy[2] = std::vector<std::size_t> {0, 1, 2, 3, 4, 5};
97 
98  std::vector<std::size_t> condMult{1u, 5u, 1u};
99  std::vector<unsigned int> condCap{0, 1, 1};
100  std::vector<int> condClique{-1, 0, 0};
101 
102  JetGroupInd2ElemInds jg2elemjgs;
103  jg2elemjgs[0] = std::vector<std::size_t> {0};
104  jg2elemjgs[1] = std::vector<std::size_t> {1};
105  jg2elemjgs[2] = std::vector<std::size_t> {2};
106  jg2elemjgs[3] = std::vector<std::size_t> {3};
107  jg2elemjgs[4] = std::vector<std::size_t> {4};
108  jg2elemjgs[5] = std::vector<std::size_t> {5};
109 
110 
111  std::size_t parCapacity{0};
112  bool simpleTree{true};
113 
114  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
115 
116  auto jgp = makeJetGroupProduct(siblings,
117  satisfiedBy,
118  condMult,
119  condCap,
120  condClique,
121  jg2elemjgs,
122  parCapacity,
123  simpleTree,
124  collector);
125 
126  EXPECT_TRUE(jgp != nullptr);
127  EXPECT_TRUE(jgp->valid());
128 
129  vec exp0{0u, 1u, 2u, 3u, 4u, 5u};
130  EXPECT_EQ(jgp->next(collector), exp0);
131  EXPECT_TRUE(jgp->next(collector).empty());
132  EXPECT_TRUE(jgp->next(collector).empty());
133 }

◆ TEST() [12/16]

TEST ( JetGroupProductFactoryTester  ,
willpass_fail_0   
)

Definition at line 439 of file JetGroupProductFactoryTest.cxx.

439  {
440  CondInd2JetGroupsInds satisfiedBy;
441  satisfiedBy[0] = std::vector<std::size_t> {};
442  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
443  satisfiedBy[2] = std::vector<std::size_t> {1};
444  satisfiedBy[3] = std::vector<std::size_t> {1};
445 
446  std::vector<std::size_t> condMult{1, 1, 1, 1};
447 
448  std::vector<std::size_t> siblings{1, 2, 3};
449 
450  EXPECT_EQ(willPassSimpleTree(siblings, satisfiedBy, condMult), false);
451 }

◆ TEST() [13/16]

TEST ( JetGroupProductFactoryTester  ,
willpass_fail_1   
)

Definition at line 453 of file JetGroupProductFactoryTest.cxx.

453  {
454  CondInd2JetGroupsInds satisfiedBy;
455  satisfiedBy[0] = std::vector<std::size_t> {};
456  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
457  satisfiedBy[2] = std::vector<std::size_t> {2};
458  satisfiedBy[3] = std::vector<std::size_t> {1};
459 
460  std::vector<std::size_t> condMult{1, 2, 1, 1};
461 
462  std::vector<std::size_t> siblings{1, 2, 3};
463 
464  EXPECT_EQ(willPassSimpleTree(siblings, satisfiedBy, condMult), false);
465 }

◆ TEST() [14/16]

TEST ( JetGroupProductFactoryTester  ,
willpass_fail_2   
)

Definition at line 468 of file JetGroupProductFactoryTest.cxx.

468  {
469  CondInd2JetGroupsInds satisfiedBy;
470  satisfiedBy[0] = std::vector<std::size_t> {};
471  satisfiedBy[1] = std::vector<std::size_t> {};
472  satisfiedBy[2] = std::vector<std::size_t> {};
473  satisfiedBy[3] = std::vector<std::size_t> {};
474 
475  std::vector<std::size_t> condMult{1, 2, 1, 1};
476 
477  std::vector<std::size_t> siblings{1, 2, 3};
478 
479  EXPECT_EQ(willPassSimpleTree(siblings, satisfiedBy, condMult), false);
480 }

◆ TEST() [15/16]

TEST ( JetGroupProductFactoryTester  ,
willpass_pass_0   
)

Definition at line 482 of file JetGroupProductFactoryTest.cxx.

482  {
483  CondInd2JetGroupsInds satisfiedBy;
484  satisfiedBy[0] = std::vector<std::size_t> {};
485  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
486  satisfiedBy[2] = std::vector<std::size_t> {2};
487  satisfiedBy[3] = std::vector<std::size_t> {1};
488 
489  std::vector<std::size_t> condMult{1, 1, 1, 1};
490 
491  std::vector<std::size_t> siblings{1, 2, 3};
492 
493  EXPECT_EQ(willPassSimpleTree(siblings, satisfiedBy, condMult), true);
494 }

◆ TEST() [16/16]

TEST ( JetGroupProductFactoryTester  ,
willpass_pass_1   
)

Definition at line 496 of file JetGroupProductFactoryTest.cxx.

496  {
497  CondInd2JetGroupsInds satisfiedBy;
498  satisfiedBy[0] = std::vector<std::size_t> {};
499  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2, 3};
500  satisfiedBy[2] = std::vector<std::size_t> {0, 1, 2};
501 
502  std::vector<std::size_t> condMult{1, 2, 2};
503 
504  std::vector<std::size_t> siblings{1, 2};
505 
506  EXPECT_EQ(willPassSimpleTree(siblings, satisfiedBy, condMult), true);
507 }
CondInd2JetGroupsInds
std::map< int, std::vector< std::size_t > > CondInd2JetGroupsInds
Definition: JetGroupProduct.h:15
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
willPassSimpleTree
bool willPassSimpleTree(const std::vector< std::size_t > &siblings, const CondInd2JetGroupsInds &satisfiedBy, const std::vector< std::size_t > &condMult)
Definition: JetGroupProductFactory.cxx:30
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
PixelAthClusterMonAlgCfg.e4
e4
Definition: PixelAthClusterMonAlgCfg.py:332
JetGroupInd2ElemInds
std::map< int, std::vector< std::size_t > > JetGroupInd2ElemInds
Definition: elementalJetGroups.h:11
makeJetGroupProduct
std::unique_ptr< IJetGroupProduct > makeJetGroupProduct(const std::vector< std::size_t > &siblings, const CondInd2JetGroupsInds &satisfiedBy, const std::vector< std::size_t > &condMult, const std::vector< unsigned int > &condCap, const std::vector< int > &condClique, const JetGroupInd2ElemInds &jg2elemjgs, std::size_t parentCap, bool simpleTree, const Collector &)
Definition: JetGroupProductFactory.cxx:73
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
egammaEnergyPositionAllSamples::e0
double e0(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in pre-sampler
max_jet
std::size_t max_jet(const std::vector< std::size_t > &siblings, const CondInd2JetGroupsInds &satisfiedBy)
Definition: JetGroupProductFactory.cxx:15
Generated on Tue Apr 22 2025 21:24:49 for ATLAS Offline Software by   doxygen 1.8.18