ATLAS Offline Software
Loading...
Searching...
No Matches
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}
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
CondInd2JetGroupsInds
std::map< int, std::vector< std::size_t > > CondInd2JetGroupsInds
Definition JetGroupProduct.h:15
JetGroupInd2ElemInds
std::map< int, std::vector< std::size_t > > JetGroupInd2ElemInds
Definition elementalJetGroups.h:11

◆ 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}
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
Trk::u
@ u
Enums for curvilinear frames.
Definition ParamDefs.h:77

◆ 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}
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
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling

◆ 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}
max_jet
std::size_t max_jet(const std::vector< std::size_t > &siblings, const CondInd2JetGroupsInds &satisfiedBy)
Definition JetGroupProductFactory.cxx:15

◆ 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}
willPassSimpleTree
bool willPassSimpleTree(const std::vector< std::size_t > &siblings, const CondInd2JetGroupsInds &satisfiedBy, const std::vector< std::size_t > &condMult)
Definition JetGroupProductFactory.cxx:30

◆ 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}
Generated on for ATLAS Offline Software by doxygen 1.14.0