Rivet API documentation

Rivet 4.1.3
ParticleBaseUtils.hh
1#ifndef RIVET_PARTICLEBASEUTILS_HH
2#define RIVET_PARTICLEBASEUTILS_HH
3
4#include "Rivet/Tools/Utils.hh"
5#include "Rivet/ParticleBase.hh"
6
7namespace Rivet {
8
9
12
18
20 using ParticleBaseSelector = function<bool(const ParticleBase&)>;
22 using ParticleBaseSorter = function<bool(const ParticleBase&, const ParticleBase&)>;
23
24
26 struct BoolParticleBaseFunctor {
27 virtual bool operator()(const ParticleBase& p) const = 0;
28 virtual ~BoolParticleBaseFunctor() {}
29 };
30
31
33 struct PtGtr : public BoolParticleBaseFunctor {
34 PtGtr(double pt) : ptcut(pt) { }
35 PtGtr(const FourMomentum& p) : ptcut(p.pT()) { }
36 bool operator()(const ParticleBase& p) const { return p.pT() > ptcut; }
37 double ptcut;
38 };
39 using pTGtr = PtGtr;
40 using ptGtr = PtGtr;
41
43 struct PtLess : public BoolParticleBaseFunctor {
44 PtLess(const FourMomentum& p) : ptcut(p.pT()) { }
45 PtLess(double pt) : ptcut(pt) { }
46 bool operator()(const ParticleBase& p) const { return p.pT() < ptcut; }
47 double ptcut;
48 };
49 using pTLess = PtLess;
50 using ptLess = PtLess;
51
53 struct PtInRange : public BoolParticleBaseFunctor {
54 PtInRange(pair<double, double> ptcuts) : ptcut(ptcuts) { }
55 PtInRange(double ptlow, double pthigh) : PtInRange(make_pair(ptlow, pthigh)) { }
56 PtInRange(const FourMomentum& p1, const FourMomentum& p2) : PtInRange(p1.pT(), p2.pT()) { }
57 bool operator()(const ParticleBase& p) const { return p.pT() >= ptcut.first && p.pT() < ptcut.second; }
58 pair<double,double> ptcut;
59 };
60 using pTInRange = PtInRange;
61 using ptInRange = PtInRange;
62
63
65 struct EtaGtr : public BoolParticleBaseFunctor {
66 EtaGtr(double eta) : etacut(eta) { }
67 EtaGtr(const FourMomentum& p) : etacut(p.eta()) { }
68 bool operator()(const ParticleBase& p) const { return p.eta() > etacut; }
69 double etacut;
70 };
71 using etaGtr = EtaGtr;
72
74 struct EtaLess : public BoolParticleBaseFunctor {
75 EtaLess(double eta) : etacut(eta) { }
76 EtaLess(const FourMomentum& p) : etacut(p.eta()) { }
77 bool operator()(const ParticleBase& p) const { return p.eta() < etacut; }
78 double etacut;
79 };
80 using etaLess = EtaLess;
81
83 struct EtaInRange : public BoolParticleBaseFunctor {
84 EtaInRange(pair<double, double> etacuts) : etacut(etacuts) { }
85 EtaInRange(double etalow, double etahigh) : EtaInRange(make_pair(etalow, etahigh)) { }
86 EtaInRange(const FourMomentum& p1, const FourMomentum& p2) : EtaInRange(p1.eta(), p2.eta()) { }
87 bool operator()(const ParticleBase& p) const { return p.eta() >= etacut.first && p.eta() < etacut.second; }
88 pair<double,double> etacut;
89 };
90 using etaInRange = EtaInRange;
91
92
94 struct AbsEtaGtr : public BoolParticleBaseFunctor {
95 AbsEtaGtr(double abseta) : absetacut(abseta) { }
96 AbsEtaGtr(const FourMomentum& p) : absetacut(p.abseta()) { }
97 bool operator()(const ParticleBase& p) const { return p.abseta() > absetacut; }
98 double absetacut;
99 };
100 using absEtaGtr = AbsEtaGtr;
101 using absetaGtr = AbsEtaGtr;
102
104 struct AbsEtaLess : public BoolParticleBaseFunctor {
105 AbsEtaLess(double abseta) : absetacut(abseta) { }
106 AbsEtaLess(const FourMomentum& p) : absetacut(p.abseta()) { }
107 bool operator()(const ParticleBase& p) const { return p.abseta() < absetacut; }
108 double absetacut;
109 };
110 using absEtaLess = AbsEtaLess;
111 using absetaLess = AbsEtaLess;
112
114 struct AbsEtaInRange : public BoolParticleBaseFunctor {
115 AbsEtaInRange(const pair<double, double>& absetacuts) : absetacut(absetacuts) { }
116 AbsEtaInRange(double absetalow, double absetahigh) : AbsEtaInRange(make_pair(absetalow, absetahigh)) { }
117 AbsEtaInRange(const FourMomentum& p1, const FourMomentum& p2) : AbsEtaInRange(p1.abseta(), p2.abseta()) { }
118 bool operator()(const ParticleBase& p) const { return p.abseta() >= absetacut.first && p.abseta() < absetacut.second; }
119 pair<double,double> absetacut;
120 };
121 using absEtaInRange = AbsEtaInRange;
122 using absetaInRange = AbsEtaInRange;
123
124
126 struct RapGtr : public BoolParticleBaseFunctor {
127 RapGtr(double rap) : rapcut(rap) { }
128 RapGtr(const FourMomentum& p) : rapcut(p.rap()) { }
129 bool operator()(const ParticleBase& p) const { return p.rap() > rapcut; }
130 double rapcut;
131 };
132 using rapGtr = RapGtr;
133
135 struct RapLess : public BoolParticleBaseFunctor {
136 RapLess(double rap) : rapcut(rap) { }
137 RapLess(const FourMomentum& p) : rapcut(p.rap()) { }
138 bool operator()(const ParticleBase& p) const { return p.rap() < rapcut; }
139 double rapcut;
140 };
141 using rapLess = RapLess;
142
144 struct RapInRange : public BoolParticleBaseFunctor {
145 RapInRange(const pair<double, double>& rapcuts) : rapcut(rapcuts) { }
146 RapInRange(double raplow, double raphigh) : RapInRange(make_pair(raplow, raphigh)) { }
147 RapInRange(const FourMomentum& p1, const FourMomentum& p2) : RapInRange(p1.rap(), p2.rap()) { }
148 bool operator()(const ParticleBase& p) const { return p.rap() >= rapcut.first && p.rap() < rapcut.second; }
149 pair<double,double> rapcut;
150 };
151 using rapInRange = RapInRange;
152
153
155 struct AbsRapGtr : public BoolParticleBaseFunctor {
156 AbsRapGtr(double absrap) : absrapcut(absrap) { }
157 AbsRapGtr(const FourMomentum& p) : absrapcut(p.absrap()) { }
158 bool operator()(const ParticleBase& p) const { return p.absrap() > absrapcut; }
159 double absrapcut;
160 };
161 using absRapGtr = AbsRapGtr;
162 using absrapGtr = AbsRapGtr;
163
165 struct AbsRapLess : public BoolParticleBaseFunctor {
166 AbsRapLess(double absrap) : absrapcut(absrap) { }
167 AbsRapLess(const FourMomentum& p) : absrapcut(p.absrap()) { }
168 bool operator()(const ParticleBase& p) const { return p.absrap() < absrapcut; }
169 double absrapcut;
170 };
171 using absRapLess = AbsRapLess;
172 using absrapLess = AbsRapLess;
173
175 struct AbsRapInRange : public BoolParticleBaseFunctor {
176 AbsRapInRange(const pair<double, double>& absrapcuts) : absrapcut(absrapcuts) { }
177 AbsRapInRange(double absraplow, double absraphigh) : AbsRapInRange(make_pair(absraplow, absraphigh)) { }
178 AbsRapInRange(const FourMomentum& p1, const FourMomentum& p2) : AbsRapInRange(p1.absrap(), p2.absrap()) { }
179 bool operator()(const ParticleBase& p) const { return p.absrap() >= absrapcut.first && p.absrap() < absrapcut.second; }
180 pair<double,double> absrapcut;
181 };
182 using absRapInRange = AbsRapInRange;
183 using absrapInRange = AbsRapInRange;
184
185
187
188
190 struct DeltaRGtr : public BoolParticleBaseFunctor {
191 DeltaRGtr(const ParticleBase& vec, double dr, RapScheme scheme=PSEUDORAPIDITY)
192 : refvec(vec.mom()), drcut(dr), rapscheme(scheme) { }
193 DeltaRGtr(const FourMomentum& vec, double dr, RapScheme scheme=PSEUDORAPIDITY)
194 : refvec(vec), drcut(dr), rapscheme(scheme) { }
195 DeltaRGtr(const Vector3& vec, double dr)
196 : drcut(dr), rapscheme(PSEUDORAPIDITY) { refvec.setPx(vec.x()); refvec.setPy(vec.y()); refvec.setPz(vec.z()); }
197 bool operator()(const ParticleBase& p) const { return deltaR(p, refvec, rapscheme) > drcut; }
198 FourMomentum refvec;
199 double drcut;
200 RapScheme rapscheme;
201 };
202 using deltaRGtr = DeltaRGtr;
203
205 struct DeltaRLess : public BoolParticleBaseFunctor {
206 DeltaRLess(const ParticleBase& vec, double dr, RapScheme scheme=PSEUDORAPIDITY)
207 : refvec(vec.mom()), drcut(dr), rapscheme(scheme) { }
208 DeltaRLess(const FourMomentum& vec, double dr, RapScheme scheme=PSEUDORAPIDITY)
209 : refvec(vec), drcut(dr), rapscheme(scheme) { }
210 DeltaRLess(const Vector3& vec, double dr)
211 : drcut(dr), rapscheme(PSEUDORAPIDITY) { refvec.setPx(vec.x()); refvec.setPy(vec.y()); refvec.setPz(vec.z()); }
212 bool operator()(const ParticleBase& p) const { return deltaR(p, refvec, rapscheme) < drcut; }
213 FourMomentum refvec;
214 double drcut;
215 RapScheme rapscheme;
216 };
217 using deltaRLess = DeltaRLess;
218
220 struct DeltaRInRange : public BoolParticleBaseFunctor {
221 DeltaRInRange(const ParticleBase& vec, const pair<double,double>& dr, RapScheme scheme=PSEUDORAPIDITY)
222 : refvec(vec.mom()), drcut(dr), rapscheme(scheme) { }
223 DeltaRInRange(const ParticleBase& vec, double drmin, double drmax, RapScheme scheme=PSEUDORAPIDITY)
224 : DeltaRInRange(vec, make_pair(drmin, drmax), scheme) { }
225 DeltaRInRange(const FourMomentum& vec, const pair<double,double>& dr, RapScheme scheme=PSEUDORAPIDITY)
226 : refvec(vec), drcut(dr), rapscheme(scheme) { }
227 DeltaRInRange(const FourMomentum& vec, double drmin, double drmax, RapScheme scheme=PSEUDORAPIDITY)
228 : DeltaRInRange(vec, make_pair(drmin, drmax), scheme) { }
229 DeltaRInRange(const Vector3& vec, const pair<double,double>& dr)
230 : drcut(dr), rapscheme(PSEUDORAPIDITY) { refvec.setPx(vec.x()); refvec.setPy(vec.y()); refvec.setPz(vec.z()); }
231 DeltaRInRange(const Vector3& vec, double drmin, double drmax)
232 : DeltaRInRange(vec, make_pair(drmin, drmax)) { }
233 bool operator()(const ParticleBase& p) const {
234 const double dR = deltaR(p, refvec, rapscheme);
235 return dR >= drcut.first && dR < drcut.second;
236 }
237 FourMomentum refvec;
238 pair<double,double> drcut;
239 RapScheme rapscheme;
240 };
241 using deltaRInRange = DeltaRInRange;
242
243
245 struct DeltaPhiGtr : public BoolParticleBaseFunctor {
246 DeltaPhiGtr(const ParticleBase& vec, double dphi)
247 : refvec(vec.p3()), dphicut(dphi) { }
248 DeltaPhiGtr(const FourMomentum& vec, double dphi)
249 : refvec(vec.p3()), dphicut(dphi) { }
250 DeltaPhiGtr(const Vector3& vec, double dphi)
251 : refvec(vec), dphicut(dphi) { }
252 bool operator()(const ParticleBase& p) const { return deltaPhi(p, refvec) > dphicut; }
253 Vector3 refvec;
254 double dphicut;
255 };
256 using deltaPhiGtr = DeltaPhiGtr;
257
259 struct DeltaPhiLess : public BoolParticleBaseFunctor {
260 DeltaPhiLess(const ParticleBase& vec, double dphi)
261 : refvec(vec.p3()), dphicut(dphi) { }
262 DeltaPhiLess(const FourMomentum& vec, double dphi)
263 : refvec(vec.p3()), dphicut(dphi) { }
264 DeltaPhiLess(const Vector3& vec, double dphi)
265 : refvec(vec), dphicut(dphi) { }
266 bool operator()(const ParticleBase& p) const { return deltaPhi(p, refvec) < dphicut; }
267 Vector3 refvec;
268 double dphicut;
269 };
270 using deltaPhiLess = DeltaPhiLess;
271
273 struct DeltaPhiInRange : public BoolParticleBaseFunctor {
274 DeltaPhiInRange(const ParticleBase& vec, const pair<double,double>& dphi)
275 : refvec(vec.mom()), dphicut(dphi) { }
276 DeltaPhiInRange(const ParticleBase& vec, double dphimin, double dphimax)
277 : DeltaPhiInRange(vec, make_pair(dphimin, dphimax)) { }
278 DeltaPhiInRange(const FourMomentum& vec, const pair<double,double>& dphi)
279 : refvec(vec), dphicut(dphi) { }
280 DeltaPhiInRange(const FourMomentum& vec, double dphimin, double dphimax)
281 : DeltaPhiInRange(vec, make_pair(dphimin, dphimax)) { }
282 DeltaPhiInRange(const Vector3& vec, const pair<double,double>& dphi)
283 : refvec(vec), dphicut(dphi) { }
284 DeltaPhiInRange(const Vector3& vec, double dphimin, double dphimax)
285 : DeltaPhiInRange(vec, make_pair(dphimin, dphimax)) { }
286 bool operator()(const ParticleBase& p) const {
287 const double dphi = deltaPhi(p, refvec);
288 return dphi >= dphicut.first && dphi < dphicut.second;
289 }
290 Vector3 refvec;
291 pair<double,double> dphicut;
292 };
293 using deltaPhiInRange = DeltaPhiInRange;
294
295
297 struct DeltaEtaGtr : public BoolParticleBaseFunctor {
298 DeltaEtaGtr(const ParticleBase& vec, double deta)
299 : refvec(vec.p3()), detacut(deta) { }
300 DeltaEtaGtr(const FourMomentum& vec, double deta)
301 : refvec(vec.p3()), detacut(deta) { }
302 DeltaEtaGtr(const Vector3& vec, double deta)
303 : refvec(vec), detacut(deta) { }
304 bool operator()(const ParticleBase& p) const { return std::abs(deltaEta(p, refvec)) > detacut; }
305 Vector3 refvec;
306 double detacut;
307 };
308 using deltaEtaGtr = DeltaEtaGtr;
309
311 struct DeltaEtaLess : public BoolParticleBaseFunctor {
312 DeltaEtaLess(const ParticleBase& vec, double deta)
313 : refvec(vec.p3()), detacut(deta) { }
314 DeltaEtaLess(const FourMomentum& vec, double deta)
315 : refvec(vec.p3()), detacut(deta) { }
316 DeltaEtaLess(const Vector3& vec, double deta)
317 : refvec(vec), detacut(deta) { }
318 bool operator()(const ParticleBase& p) const { return std::abs(deltaEta(p, refvec)) < detacut; }
319 Vector3 refvec;
320 double detacut;
321 };
322 using deltaEtaLess = DeltaEtaLess;
323
325 struct DeltaEtaInRange : public BoolParticleBaseFunctor {
326 DeltaEtaInRange(const ParticleBase& vec, const pair<double,double>& deta)
327 : refvec(vec.mom()), detacut(deta) { }
328 DeltaEtaInRange(const ParticleBase& vec, double detamin, double detamax)
329 : DeltaEtaInRange(vec, make_pair(detamin, detamax)) { }
330 DeltaEtaInRange(const FourMomentum& vec, const pair<double,double>& deta)
331 : refvec(vec), detacut(deta) { }
332 DeltaEtaInRange(const FourMomentum& vec, double detamin, double detamax)
333 : DeltaEtaInRange(vec, make_pair(detamin, detamax)) { }
334 DeltaEtaInRange(const Vector3& vec, const pair<double,double>& deta)
335 : refvec(vec), detacut(deta) { }
336 DeltaEtaInRange(const Vector3& vec, double detamin, double detamax)
337 : DeltaEtaInRange(vec, make_pair(detamin, detamax)) { }
338 bool operator()(const ParticleBase& p) const {
339 const double deta = deltaEta(p, refvec);
340 return deta >= detacut.first && deta < detacut.second;
341 }
342 Vector3 refvec;
343 pair<double,double> detacut;
344 };
345 using deltaEtaInRange = DeltaEtaInRange;
346
347
349 struct DeltaRapGtr : public BoolParticleBaseFunctor {
350 DeltaRapGtr(const ParticleBase& vec, double drap)
351 : refvec(vec.mom()), drapcut(drap) { }
352 DeltaRapGtr(const FourMomentum& vec, double drap)
353 : refvec(vec), drapcut(drap) { }
354 bool operator()(const ParticleBase& p) const { return std::abs(deltaRap(p, refvec)) > drapcut; }
355 FourMomentum refvec;
356 double drapcut;
357 };
358 using deltaRapGtr = DeltaRapGtr;
359
361 struct DeltaRapLess : public BoolParticleBaseFunctor {
362 DeltaRapLess(const ParticleBase& vec, double drap)
363 : refvec(vec.mom()), drapcut(drap) { }
364 DeltaRapLess(const FourMomentum& vec, double drap)
365 : refvec(vec), drapcut(drap) { }
366 bool operator()(const ParticleBase& p) const { return std::abs(deltaRap(p, refvec)) < drapcut; }
367 FourMomentum refvec;
368 double drapcut;
369 };
370 using deltaRapLess = DeltaRapLess;
371
373 struct DeltaRapInRange : public BoolParticleBaseFunctor {
374 DeltaRapInRange(const ParticleBase& vec, const pair<double,double>& drap)
375 : refvec(vec.mom()), drapcut(drap) { }
376 DeltaRapInRange(const ParticleBase& vec, double drapmin, double drapmax)
377 : DeltaRapInRange(vec, make_pair(drapmin, drapmax)) { }
378 DeltaRapInRange(const FourMomentum& vec, const pair<double,double>& drap)
379 : refvec(vec), drapcut(drap) { }
380 DeltaRapInRange(const FourMomentum& vec, double drapmin, double drapmax)
381 : DeltaRapInRange(vec, make_pair(drapmin, drapmax)) { }
382 bool operator()(const ParticleBase& p) const {
383 const double drap = deltaRap(p, refvec);
384 return drap >= drapcut.first && drap < drapcut.second;
385 }
386 FourMomentum refvec;
387 pair<double,double> drapcut;
388 };
389 using deltaRapInRange = DeltaRapInRange;
390
392
393
399
401 struct DoubleParticleBaseFunctor {
402 virtual double operator()(const ParticleBase& p) const = 0;
403 virtual ~DoubleParticleBaseFunctor() {}
404 };
405
407 struct DeltaRWRT : public DoubleParticleBaseFunctor {
408 DeltaRWRT(const ParticleBase& pb, RapScheme scheme=PSEUDORAPIDITY) : p(pb.mom()), rapscheme(scheme) {}
409 DeltaRWRT(const FourMomentum& p4, RapScheme scheme=PSEUDORAPIDITY) : p(p4), rapscheme(scheme) {}
410 DeltaRWRT(const Vector3& p3) : p(p3.mod(), p3.x(), p3.y(), p3.z()), rapscheme(PSEUDORAPIDITY) {}
411 double operator()(const ParticleBase& pb) const { return deltaR(p, pb, rapscheme); }
412 double operator()(const FourMomentum& p4) const { return deltaR(p, p4, rapscheme); }
413 double operator()(const Vector3& p3) const { return deltaR(p, p3); }
414 const FourMomentum p;
415 RapScheme rapscheme;
416 };
417 using deltaRWRT = DeltaRWRT;
418
420 struct DeltaPhiWRT : public DoubleParticleBaseFunctor {
421 DeltaPhiWRT(const ParticleBase& pb) : p(pb.mom().vector3()) {}
422 DeltaPhiWRT(const FourMomentum& p4) : p(p4.vector3()) {}
423 DeltaPhiWRT(const Vector3& p3) : p(p3) {}
424 double operator()(const ParticleBase& pb) const { return deltaPhi(p, pb); }
425 double operator()(const FourMomentum& p4) const { return deltaPhi(p, p4); }
426 double operator()(const Vector3& p3) const { return deltaPhi(p, p3); }
427 const Vector3 p;
428 };
429 using deltaPhiWRT = DeltaPhiWRT;
430
432 struct DeltaEtaWRT : public DoubleParticleBaseFunctor {
433 DeltaEtaWRT(const ParticleBase& pb) : p(pb.mom().vector3()) {}
434 DeltaEtaWRT(const FourMomentum& p4) : p(p4.vector3()) {}
435 DeltaEtaWRT(const Vector3& p3) : p(p3) {}
436 double operator()(const ParticleBase& pb) const { return deltaEta(p, pb); }
437 double operator()(const FourMomentum& p4) const { return deltaEta(p, p4); }
438 double operator()(const Vector3& p3) const { return deltaEta(p, p3); }
439 const Vector3 p;
440 };
441 using deltaEtaWRT = DeltaEtaWRT;
442
444 struct AbsDeltaEtaWRT : public DoubleParticleBaseFunctor {
445 AbsDeltaEtaWRT(const ParticleBase& pb) : p(pb.mom().vector3()) {}
446 AbsDeltaEtaWRT(const FourMomentum& p4) : p(p4.vector3()) {}
447 AbsDeltaEtaWRT(const Vector3& p3) : p(p3) {}
448 double operator()(const ParticleBase& pb) const { return fabs(deltaEta(p, pb)); }
449 double operator()(const FourMomentum& p4) const { return fabs(deltaEta(p, p4)); }
450 double operator()(const Vector3& p3) const { return fabs(deltaEta(p, p3)); }
451 const Vector3 p;
452 };
453 using absDeltaEtaWRT = AbsDeltaEtaWRT;
454
456 struct DeltaRapWRT : public DoubleParticleBaseFunctor {
457 DeltaRapWRT(const ParticleBase& pb) : p(pb.mom()) {}
458 DeltaRapWRT(const FourMomentum& p4) : p(p4) {}
459 double operator()(const ParticleBase& pb) const { return deltaRap(p, pb); }
460 double operator()(const FourMomentum& p4) const { return deltaRap(p, p4); }
461 const FourMomentum p;
462 };
463 using deltaRapWRT = DeltaRapWRT;
464
466 struct AbsDeltaRapWRT : public DoubleParticleBaseFunctor {
467 AbsDeltaRapWRT(const ParticleBase& pb) : p(pb.mom()) {}
468 AbsDeltaRapWRT(const FourMomentum& p4) : p(p4) {}
469 double operator()(const ParticleBase& pb) const { return fabs(deltaRap(p, pb)); }
470 double operator()(const FourMomentum& p4) const { return fabs(deltaRap(p, p4)); }
471 const FourMomentum p;
472 };
473 using absDeltaRapWRT = AbsDeltaRapWRT;
474
476
477
480
481 template<typename PBCONTAINER1, typename PBCONTAINER2>
482 inline void idiscardIfAny(PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare,
483 typename std::function<bool(const typename PBCONTAINER1::value_type&,
484 const typename PBCONTAINER2::value_type&)> fn) {
485 for (const auto& pbcmp : tocompare) {
486 idiscard(tofilter, [&](const typename PBCONTAINER1::value_type& pbfilt){ return fn(pbfilt, pbcmp); });
487 }
488 }
489
490 template<typename PBCONTAINER1, typename PBCONTAINER2>
491 inline PBCONTAINER1 discardIfAny(const PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare,
492 typename std::function<bool(const typename PBCONTAINER1::value_type&,
493 const typename PBCONTAINER2::value_type&)> fn) {
494 PBCONTAINER1 tmp{tofilter};
495 idiscardIfAny(tmp, tocompare, fn);
496 return tmp;
497 }
498
499
500 template<typename PBCONTAINER1, typename PBCONTAINER2>
501 inline PBCONTAINER1 selectIfAny(const PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare,
502 typename std::function<bool(const typename PBCONTAINER1::value_type&,
503 const typename PBCONTAINER2::value_type&)> fn) {
504 PBCONTAINER1 selected;
505 for (const auto& pbfilt : tofilter) {
506 if (any(tocompare, [&](const typename PBCONTAINER2::value_type& pbcmp){ return fn(pbfilt, pbcmp); })) {
507 selected += pbfilt;
508 }
509 }
510 return selected;
511 }
512
513 template<typename PBCONTAINER1, typename PBCONTAINER2>
514 inline void iselectIfAny(PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare,
515 typename std::function<bool(const typename PBCONTAINER1::value_type&,
516 const typename PBCONTAINER2::value_type&)> fn) {
517 tofilter = selectIfAny(tofilter, tocompare, fn);
518 }
519
520
521
522 template<typename PBCONTAINER1, typename PBCONTAINER2>
523 inline PBCONTAINER1 discardIfAll(const PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare,
524 typename std::function<bool(const typename PBCONTAINER1::value_type&,
525 const typename PBCONTAINER2::value_type&)> fn) {
526 PBCONTAINER1 selected;
527 for (const auto& pbfilt : tofilter) {
528 if (!all(tocompare, [&](const typename PBCONTAINER2::value_type& pbcmp){ return fn(pbfilt, pbcmp); })) {
529 selected += pbfilt;
530 }
531 }
532 return selected;
533 }
534
535 template<typename PBCONTAINER1, typename PBCONTAINER2>
536 inline void idiscardIfAll(PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare,
537 typename std::function<bool(const typename PBCONTAINER1::value_type&,
538 const typename PBCONTAINER2::value_type&)> fn) {
539 tofilter = discardIfAll(tofilter, tocompare, fn);
540 }
541
542
543 template<typename PBCONTAINER1, typename PBCONTAINER2>
544 inline PBCONTAINER1 selectIfAll(const PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare,
545 typename std::function<bool(const typename PBCONTAINER1::value_type&,
546 const typename PBCONTAINER2::value_type&)> fn) {
547 PBCONTAINER1 selected;
548 for (const auto& pbfilt : tofilter) {
549 if (all(tocompare, [&](const typename PBCONTAINER2::value_type& pbcmp){ return fn(pbfilt, pbcmp); })) {
550 selected += pbfilt;
551 }
552 }
553 return selected;
554 }
555
556 template<typename PBCONTAINER1, typename PBCONTAINER2>
557 inline void iselectIfAll(PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare,
558 typename std::function<bool(const typename PBCONTAINER1::value_type&,
559 const typename PBCONTAINER2::value_type&)> fn) {
560 tofilter = selectIfAll(tofilter, tocompare, fn);
561 }
562
564
565
568
569 template<typename PBCONTAINER1, typename PBCONTAINER2>
570 inline void idiscardIfAnyDeltaRLess(PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare, double dR) {
571 for (const typename PBCONTAINER2::value_type& pb : tocompare) {
572 idiscard(tofilter, deltaRLess(pb, dR));
573 }
574 }
575
576 template<typename PBCONTAINER1, typename PBCONTAINER2>
577 inline PBCONTAINER1 discardIfAnyDeltaRLess(const PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare, double dR) {
578 PBCONTAINER1 tmp{tofilter};
579 idiscardIfAnyDeltaRLess(tmp, tocompare, dR);
580 return tmp;
581 }
582
583 template<typename PBCONTAINER1, typename PBCONTAINER2>
584 inline void idiscardIfAnyDeltaPhiLess(PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare, double dphi) {
585 for (const typename PBCONTAINER2::value_type& pb : tocompare) {
586 idiscard(tofilter, deltaPhiLess(pb, dphi));
587 }
588 }
589
590 template<typename PBCONTAINER1, typename PBCONTAINER2>
591 inline PBCONTAINER1 discardIfAnyDeltaPhiLess(const PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare, double dphi) {
592 PBCONTAINER1 tmp{tofilter};
593 idiscardIfAnyDeltaPhiLess(tmp, tocompare, dphi);
594 return tmp;
595 }
596
597
598
599 template<typename PBCONTAINER1, typename PBCONTAINER2>
600 inline PBCONTAINER1 selectIfAnyDeltaRLess(const PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare, double dR) {
601 PBCONTAINER1 selected;
602 for (const typename PBCONTAINER1::value_type& f : tofilter) {
603 if (any(tocompare, deltaRLess(f, dR))) selected.push_back(f);
604 }
605 return selected;
606 }
607
608 template<typename PBCONTAINER1, typename PBCONTAINER2>
609 inline void iselectIfAnyDeltaRLess(PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare, double dR) {
610 tofilter = selectIfAnyDeltaRLess(tofilter, tocompare, dR);
611 }
612
613
614 template<typename PBCONTAINER1, typename PBCONTAINER2>
615 inline PBCONTAINER1 selectIfAnyDeltaPhiLess(const PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare, double dphi) {
616 PBCONTAINER1 selected;
617 for (const typename PBCONTAINER1::value_type& f : tofilter) {
618 if (any(tocompare, deltaPhiLess(f, dphi))) selected.push_back(f);
619 }
620 return selected;
621 }
622
623 template<typename PBCONTAINER1, typename PBCONTAINER2>
624 inline void iselectIfAnyDeltaPhiLess(PBCONTAINER1& tofilter, const PBCONTAINER2& tocompare, double dphi) {
625 tofilter = selectIfAnyDeltaPhiLess(tofilter, tocompare, dphi);
626 }
627
628
630
632
633
639 namespace Kin {
640
642 inline FourMomentum mom(const ParticleBase& p) { return p.mom(); }
644 inline FourMomentum p4(const ParticleBase& p) { return p.mom(); }
645
647 inline Vector3 p3(const ParticleBase& p) { return p.p3(); }
648
650 inline Vector3 pTvec(const ParticleBase& p) { return p.pTvec(); }
651
653 inline double p(const ParticleBase& p) { return p.p(); }
654
656 inline double pT(const ParticleBase& p) { return p.pT(); }
657
659 inline double E(const ParticleBase& p) { return p.E(); }
660
662 inline double Et(const ParticleBase& p) { return p.Et(); }
663
665 inline double eta(const ParticleBase& p) { return p.eta(); }
666
668 inline double abseta(const ParticleBase& p) { return p.abseta(); }
669
671 inline double rap(const ParticleBase& p) { return p.rap(); }
672
674 inline double absrap(const ParticleBase& p) { return p.absrap(); }
675
677 inline double mass(const ParticleBase& p) { return p.mass(); }
678
679
680 // /// Unbound function access to pair pT
681 // inline double pairPt(const ParticleBase& p1, const ParticleBase& p2) { return (p1.mom() + p2.mom()).pT(); }
682
683 // /// Unbound function access to pair mass
684 // inline double pairMass(const ParticleBase& p1, const ParticleBase& p2) { return (p1.mom() + p2.mom()).mass(); }
685
686
688 inline double mass(const ParticleBase& p, const FourMomentum& p4) {
689 return mass(p.mom(), p4);
690 }
691
693 inline double mass(const FourMomentum& p4, const ParticleBase& p) {
694 return mass(p4, p.mom());
695 }
696
698 inline double mass(const ParticleBase& p1, const ParticleBase& p2) {
699 return mass(p1.mom(), p2.mom());
700 }
701
703 inline double mass2(const ParticleBase& p, const P4& p4) {
704 return mass2(p.mom(), p4);
705 }
706
708 inline double mass2(const P4& p4, const ParticleBase& p) {
709 return mass2(p4, p.mom());
710 }
711
713 inline double mass2(const ParticleBase& p1, const ParticleBase& p2) {
714 return mass2(p1.mom(), p2.mom());
715 }
716
721 inline double mT(const ParticleBase& p, const P4& p4) {
722 return mT(p.mom(), p4);
723 }
724
729 inline double mT(const P4& p4, const ParticleBase& p) {
730 return mT(p4, p.mom());
731 }
732
737 inline double mT(const ParticleBase& p1, const ParticleBase& p2) {
738 return mT(p1.mom(), p2.mom());
739 }
740
745 inline double mT(const ParticleBase& p1, const Vector4& p2) {
746 return mT(p1.mom(), p2);
747 }
748
753 inline double mT(const Vector4& p1, const ParticleBase& p2) {
754 return mT(p1, p2.mom());
755 }
756
761 inline double mT(const ParticleBase& p1, const Vector3& p2) {
762 return mT(p1.mom(), p2);
763 }
764
769 inline double mT(const Vector3& p1, const ParticleBase& p2) {
770 return mT(p1, p2.mom());
771 }
772
774 inline double pT(const ParticleBase& p, const P4& p4) {
775 return pT(p.mom(), p4);
776 }
777
779 inline double pT(const P4& p4, const ParticleBase& p) {
780 return pT(p4, p.mom());
781 }
782
784 inline double pT(const ParticleBase& p1, const ParticleBase& p2) {
785 return pT(p1.mom(), p2.mom());
786 }
787
788 }
789
790 // Import Kin namespace into Rivet
791 using namespace Kin;
792
794
795
798
803 // auto closestMassIndex = std::bind(closestMatchIndex, std::placeholders::_1, Kin::mass, std::placeholders::_2, std::placeholders::_3);
804 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
805 inline int closestMassIndex(const CONTAINER& c, double mtarget, double mmin=-DBL_MAX, double mmax=DBL_MAX) {
806 return closestMatchIndex(c, Kin::mass, mtarget, mmin, mmax);
807 }
808
813 template <typename CONTAINER1, typename CONTAINER2, typename = isCIterable<CONTAINER1, CONTAINER2>>
814 inline pair<int,int> closestMassIndices(const CONTAINER1& c1, const CONTAINER2& c2,
815 double mtarget, double mmin=-DBL_MAX, double mmax=DBL_MAX) {
816 return closestMatchIndices(c1, c2, Kin::mass, mtarget, mmin, mmax);
817 }
818
823 template <typename CONTAINER, typename T, typename = isCIterable<CONTAINER>>
824 inline int closestMassIndex(const CONTAINER& c, const T& x,
825 double mtarget, double mmin=-DBL_MAX, double mmax=DBL_MAX) {
826 using FN = double(const ParticleBase&, const T&);
827 return closestMatchIndex<CONTAINER, T, FN>(c, x, Kin::mass, mtarget, mmin, mmax);
828 }
829
830
835 template <typename CONTAINER, typename T, typename = isCIterable<CONTAINER>>
836 inline int closestMassIndex(const T& x, const CONTAINER& c,
837 double mtarget, double mmin=-DBL_MAX, double mmax=DBL_MAX) {
838 return closestMatchIndex(x, c, Kin::mass, mtarget, mmin, mmax);
839 }
840
842
843
846
848 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
849 inline double sumPt(const CONTAINER& c) {
850 return sum(c, Kin::pT, 0.0);
851 }
852
854 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
855 inline double sumE(const CONTAINER& c) {
856 return sum(c, Kin::E, 0.0);
857 }
858
860 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
861 inline double sumEt(const CONTAINER& c) {
862 return sum(c, Kin::Et, 0.0);
863 }
864
866 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
867 inline double sumMass(const CONTAINER& c) {
868 return sum(c, Kin::mass, 0.0);
869 }
870
872 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
873 inline FourMomentum sumP4(const CONTAINER& c) {
874 return sum(c, Kin::p4, FourMomentum());
875 }
876
878 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
879 inline Vector3 sumP3(const CONTAINER& c) {
880 return sum(c, Kin::p3, Vector3());
881 }
882
884 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
885 inline Vector3 sumPtVec(const CONTAINER& c) {
886 return sum(c, Kin::pTvec, Vector3());
887 }
888
889
895 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
896 inline double deltaPhiMin(const CONTAINER& c) {
897 double rtn = DBL_MAX;
898 for (size_t i = 0; i < c.size(); ++i) {
899 for (size_t j = i; j < c.size(); ++j) {
900 if (i == j) continue;
901 const double dphi = fabs(deltaPhi(c[i], c[j]));
902 if (dphi < rtn) rtn = dphi;
903 }
904 }
905 return rtn;
906 }
907
915 template <typename CONTAINER1, typename CONTAINER2, typename = isCIterable<CONTAINER1, CONTAINER2>>
916 inline double deltaPhiMin(const CONTAINER1& c1, const CONTAINER2& c2) {
917 double rtn = DBL_MAX;
918 for (size_t i = 0; i < c1.size(); ++i) {
919 for (size_t j = 0; j < c2.size(); ++j) {
920 const double dphi = deltaPhi(c1[i], c2[j]);
921 if (dphi < rtn) rtn = dphi;
922 }
923 }
924 return rtn;
925 }
926
927
928
934 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
935 inline double deltaEtaMin(const CONTAINER& c) {
936 double rtn = DBL_MAX;
937 for (size_t i = 0; i < c.size(); ++i) {
938 for (size_t j = i; j < c.size(); ++j) {
939 if (i == j) continue;
940 const double deta = fabs(deltaEta(c[i], c[j]));
941 if (deta < rtn) rtn = deta;
942 }
943 }
944 return rtn;
945 }
946
954 template <typename CONTAINER1, typename CONTAINER2, typename = isCIterable<CONTAINER1, CONTAINER2>>
955 inline double deltaEtaMin(const CONTAINER1& c1, const CONTAINER2& c2) {
956 double rtn = DBL_MAX;
957 for (size_t i = 0; i < c1.size(); ++i) {
958 for (size_t j = 0; j < c2.size(); ++j) {
959 const double deta = deltaEta(c1[i], c2[j]);
960 if (deta < rtn) rtn = deta;
961 }
962 }
963 return rtn;
964 }
965
966
972 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
973 inline double deltaRapMin(const CONTAINER& c) {
974 double rtn = DBL_MAX;
975 for (size_t i = 0; i < c.size(); ++i) {
976 for (size_t j = i; j < c.size(); ++j) {
977 if (i == j) continue;
978 const double dy = fabs(deltaRap(c[i], c[j]));
979 if (dy < rtn) rtn = dy;
980 }
981 }
982 return rtn;
983 }
984
992 template <typename CONTAINER1, typename CONTAINER2, typename = isCIterable<CONTAINER1, CONTAINER2>>
993 inline double deltaRapMin(const CONTAINER1& c1, const CONTAINER2& c2) {
994 double rtn = DBL_MAX;
995 for (size_t i = 0; i < c1.size(); ++i) {
996 for (size_t j = 0; j < c2.size(); ++j) {
997 const double dy = deltaRap(c1[i], c2[j]);
998 if (dy < rtn) rtn = dy;
999 }
1000 }
1001 return rtn;
1002 }
1003
1004
1005
1011 template <typename CONTAINER, typename = isCIterable<CONTAINER>>
1012 inline double deltaRMin(const CONTAINER& c) {
1013 double rtn = DBL_MAX;
1014 for (size_t i = 0; i < c.size(); ++i) {
1015 for (size_t j = i; j < c.size(); ++j) {
1016 if (i == j) continue;
1017 const double dr = fabs(deltaR(c[i], c[j]));
1018 if (dr < rtn) rtn = dr;
1019 }
1020 }
1021 return rtn;
1022 }
1023
1031 template <typename CONTAINER1, typename CONTAINER2, typename = isCIterable<CONTAINER1, CONTAINER2>>
1032 inline double deltaRMin(const CONTAINER1& c1, const CONTAINER2& c2) {
1033 double rtn = DBL_MAX;
1034 for (size_t i = 0; i < c1.size(); ++i) {
1035 for (size_t j = 0; j < c2.size(); ++j) {
1036 const double dr = deltaR(c1[i], c2[j]);
1037 if (dr < rtn) rtn = dr;
1038 }
1039 }
1040 return rtn;
1041 }
1042
1043
1045 template <typename CONTAINER, typename PVEC, typename = isCIterable<CONTAINER>>
1046 inline double mTmin(const CONTAINER& psvis, const PVEC& pinvis) {
1047 return min(transform(psvis, [&](const typename CONTAINER::value_type& pvis) { return mT(pvis, pinvis); }));
1048 }
1049
1051
1052}
1053
1054#endif
Rivet::FourMomentum
Specialized version of the FourVector with momentum/energy functionality.
Definition Vector4.hh:327
Rivet::FourMomentum::rap
double rap() const
Alias for rapidity.
Definition Vector4.hh:632
Rivet::FourMomentum::absrap
double absrap() const
Absolute rapidity.
Definition Vector4.hh:641
Rivet::FourMomentum::pT
double pT() const
Calculate the transverse momentum .
Definition Vector4.hh:664
Rivet::FourVector::vector3
Vector3 vector3() const
Get the spatial part of the 4-vector as a 3-vector.
Definition Vector4.hh:184
Rivet::FourVector::abseta
double abseta() const
Get the directly (alias).
Definition Vector4.hh:181
Rivet::FourVector::eta
double eta() const
Synonym for pseudorapidity.
Definition Vector4.hh:174
Rivet::ParticleBase
Base class for particle-like things like Particle and Jet.
Definition ParticleBase.hh:13
Rivet::ParticleBase::mom
const FourMomentum & mom() const
Get the equivalent momentum four-vector (const) (alias).
Definition ParticleBase.hh:39
Rivet::ParticleBase::p3
ThreeMomentum p3() const
Get the 3-momentum directly.
Definition ParticleBase.hh:110
Rivet::Vector3
Three-dimensional specialisation of Vector.
Definition Vector3.hh:40
Rivet::closestMatchIndex
int closestMatchIndex(const CONTAINER &c, FN &&fn, double target, double minval=-DBL_MAX, double maxval=DBL_MAX)
Return the index from a vector which best matches fn(c[i]) to the target value.
Definition Utils.hh:786
Rivet::closestMatchIndices
pair< int, int > closestMatchIndices(const CONTAINER1 &c1, const CONTAINER2 &c2, FN &&fn, double target, double minval=-DBL_MAX, double maxval=DBL_MAX)
Return the indices from two vectors which best match fn(c1[i], c2[j]) to the target value.
Definition Utils.hh:815
Rivet::any
bool any(const CONTAINER &c)
Return true if x is true for any x in container c, otherwise false.
Definition Utils.hh:358
Rivet::all
bool all(const CONTAINER &c)
Return true if x is true for all x in container c, otherwise false.
Definition Utils.hh:383
Rivet::idiscard
Jets & idiscard(Jets &jets, const Cut &c)
Filter a jet collection in-place to the subset that fails the supplied Cut.
Rivet::ParticleBaseSelector
function< bool(const ParticleBase &)> ParticleBaseSelector
std::function instantiation for functors taking a ParticleBase and returning a bool
Definition ParticleBaseUtils.hh:20
Rivet::ParticleBaseSorter
function< bool(const ParticleBase &, const ParticleBase &)> ParticleBaseSorter
std::function instantiation for functors taking two ParticleBase and returning a bool
Definition ParticleBaseUtils.hh:22
Rivet::Kin::pT
double pT(const ParticleBase &p)
Unbound function access to pT.
Definition ParticleBaseUtils.hh:656
Rivet::Kin::p4
FourMomentum p4(const ParticleBase &p)
Unbound function access to momentum.
Definition ParticleBaseUtils.hh:644
Rivet::Kin::pTvec
Vector3 pTvec(const ParticleBase &p)
Unbound function access to pTvec.
Definition ParticleBaseUtils.hh:650
Rivet::Kin::p3
Vector3 p3(const ParticleBase &p)
Unbound function access to p3.
Definition ParticleBaseUtils.hh:647
Rivet::Kin::mom
FourMomentum mom(const ParticleBase &p)
Unbound function access to momentum.
Definition ParticleBaseUtils.hh:642
Rivet::Kin::absrap
double absrap(const ParticleBase &p)
Unbound function access to abs rapidity.
Definition ParticleBaseUtils.hh:674
Rivet::Kin::E
double E(const ParticleBase &p)
Unbound function access to E.
Definition ParticleBaseUtils.hh:659
Rivet::Kin::eta
double eta(const ParticleBase &p)
Unbound function access to eta.
Definition ParticleBaseUtils.hh:665
Rivet::Kin::mass
double mass(const ParticleBase &p)
Unbound function access to mass.
Definition ParticleBaseUtils.hh:677
Rivet::Kin::mass2
double mass2(const ParticleBase &p, const P4 &p4)
Get the mass^2 of a ParticleBase and a P4.
Definition ParticleBaseUtils.hh:703
Rivet::Kin::rap
double rap(const ParticleBase &p)
Unbound function access to rapidity.
Definition ParticleBaseUtils.hh:671
Rivet::Kin::Et
double Et(const ParticleBase &p)
Unbound function access to ET.
Definition ParticleBaseUtils.hh:662
Rivet::Kin::p
double p(const ParticleBase &p)
Unbound function access to p.
Definition ParticleBaseUtils.hh:653
Rivet::Kin::abseta
double abseta(const ParticleBase &p)
Unbound function access to abseta.
Definition ParticleBaseUtils.hh:668
Rivet::Kin::mT
double mT(const ParticleBase &p, const P4 &p4)
Get the transverse mass of a ParticleBase and a P4.
Definition ParticleBaseUtils.hh:721
Rivet::closestMassIndex
int closestMassIndex(const CONTAINER &c, double mtarget, double mmin=-DBL_MAX, double mmax=DBL_MAX)
Return the index from a vector which best matches mass(c[i]) to the target value.
Definition ParticleBaseUtils.hh:805
Rivet::closestMassIndices
pair< int, int > closestMassIndices(const CONTAINER1 &c1, const CONTAINER2 &c2, double mtarget, double mmin=-DBL_MAX, double mmax=DBL_MAX)
Return the indices from two vectors which best match mass(c1[i], c2[j]) to the target value.
Definition ParticleBaseUtils.hh:814
Rivet::mTmin
double mTmin(const CONTAINER &psvis, const PVEC &pinvis)
Get the minimum transverse mass of a pair of vectors, one of them taken from a list.
Definition ParticleBaseUtils.hh:1046
Rivet::sumEt
double sumEt(const CONTAINER &c)
Return the ET sum of a collection of particle-like objects.
Definition ParticleBaseUtils.hh:861
Rivet::deltaEtaMin
double deltaEtaMin(const CONTAINER &c)
Calculate the minimum pseudorapidity separation in a collection of particle-like objects.
Definition ParticleBaseUtils.hh:935
Rivet::deltaRapMin
double deltaRapMin(const CONTAINER &c)
Calculate the minimum rapidity separation in a collection of particle-like objects.
Definition ParticleBaseUtils.hh:973
Rivet::sumE
double sumE(const CONTAINER &c)
Return the energy sum of a collection of particle-like objects.
Definition ParticleBaseUtils.hh:855
Rivet::deltaRMin
double deltaRMin(const CONTAINER &c)
Calculate the minimum rapidity separation in a collection of particle-like objects.
Definition ParticleBaseUtils.hh:1012
Rivet::sumPt
double sumPt(const CONTAINER &c)
Return the pT sum of a collection of particle-like objects.
Definition ParticleBaseUtils.hh:849
Rivet::sumPtVec
Vector3 sumPtVec(const CONTAINER &c)
Return the four-momentum sum of a collection of particle-like objects.
Definition ParticleBaseUtils.hh:885
Rivet::sumP4
FourMomentum sumP4(const CONTAINER &c)
Return the four-momentum sum of a collection of particle-like objects.
Definition ParticleBaseUtils.hh:873
Rivet::sumMass
double sumMass(const CONTAINER &c)
Return the mass sum of a collection of particle-like objects.
Definition ParticleBaseUtils.hh:867
Rivet::deltaPhiMin
double deltaPhiMin(const CONTAINER &c)
Calculate the minimum phi separation in a collection of particle-like objects.
Definition ParticleBaseUtils.hh:896
Rivet::sumP3
Vector3 sumP3(const CONTAINER &c)
Return the four-momentum sum of a collection of particle-like objects.
Definition ParticleBaseUtils.hh:879
Rivet
Definition MC_CENT_PPB_Projections.hh:10
Rivet::deltaR
double deltaR(double rap1, double phi1, double rap2, double phi2)
Definition MathUtils.hh:708
Rivet::deltaPhi
double deltaPhi(double phi1, double phi2, bool sign=false)
Calculate the difference between two angles in radians.
Definition MathUtils.hh:678
Rivet::deltaEta
double deltaEta(double eta1, double eta2, bool sign=false)
Definition MathUtils.hh:686
Rivet::mT
double mT(double pT1, double pT2, double dphi)
Definition MathUtils.hh:731
Rivet::sum
T sum(const DressedLeptons &c, FN &&fn, const T &start=T())
Generic sum function, adding fn(x) for all x in container c, starting with start.
Definition DressedLepton.hh:60
Rivet::min
std::enable_if_t< std::is_arithmetic_v< N1 > &&std::is_arithmetic_v< N2 >, signed_if_mixed_t< N1, N2 > > min(N1 a, N2 b)
Get the minimum of two numbers.
Definition MathUtils.hh:104
Rivet::RapScheme
RapScheme
Enum for rapidity variable to be used in calculating , applying rapidity cuts, etc.
Definition MathConstants.hh:46
Rivet::deltaRap
double deltaRap(double y1, double y2, bool sign=false)
Definition MathUtils.hh:694
Rivet::AbsDeltaEtaWRT
Calculator of with respect to a given momentum.
Definition ParticleBaseUtils.hh:444
Rivet::AbsDeltaRapWRT
Calculator of with respect to a given momentum.
Definition ParticleBaseUtils.hh:466
Rivet::AbsEtaGtr
Abs pseudorapidity greater-than functor.
Definition ParticleBaseUtils.hh:94
Rivet::AbsEtaInRange
Abs pseudorapidity in-range functor.
Definition ParticleBaseUtils.hh:114
Rivet::AbsEtaLess
Abs pseudorapidity momentum less-than functor.
Definition ParticleBaseUtils.hh:104
Rivet::AbsRapGtr
Abs rapidity greater-than functor.
Definition ParticleBaseUtils.hh:155
Rivet::AbsRapInRange
Abs rapidity in-range functor.
Definition ParticleBaseUtils.hh:175
Rivet::AbsRapLess
Abs rapidity momentum less-than functor.
Definition ParticleBaseUtils.hh:165
Rivet::BoolParticleBaseFunctor
Base type for Particle -> bool functors.
Definition ParticleBaseUtils.hh:26
Rivet::DeltaEtaGtr
(with respect to another momentum, vec) greater-than functor
Definition ParticleBaseUtils.hh:297
Rivet::DeltaEtaInRange
(with respect to another 4-momentum, vec) in-range functor
Definition ParticleBaseUtils.hh:325
Rivet::DeltaEtaLess
(with respect to another momentum, vec) less-than functor
Definition ParticleBaseUtils.hh:311
Rivet::DeltaEtaWRT
Calculator of with respect to a given momentum.
Definition ParticleBaseUtils.hh:432
Rivet::DeltaPhiGtr
(with respect to another momentum, vec) greater-than functor
Definition ParticleBaseUtils.hh:245
Rivet::DeltaPhiInRange
(with respect to another 4-momentum, vec) in-range functor
Definition ParticleBaseUtils.hh:273
Rivet::DeltaPhiLess
(with respect to another momentum, vec) less-than functor
Definition ParticleBaseUtils.hh:259
Rivet::DeltaPhiWRT
Calculator of with respect to a given momentum.
Definition ParticleBaseUtils.hh:420
Rivet::DeltaRGtr
(with respect to another 4-momentum, vec) greater-than functor
Definition ParticleBaseUtils.hh:190
Rivet::DeltaRInRange
(with respect to another 4-momentum, vec) in-range functor
Definition ParticleBaseUtils.hh:220
Rivet::DeltaRLess
(with respect to another 4-momentum, vec) less-than functor
Definition ParticleBaseUtils.hh:205
Rivet::DeltaRWRT
Calculator of with respect to a given momentum.
Definition ParticleBaseUtils.hh:407
Rivet::DeltaRapGtr
(with respect to another momentum, vec) greater-than functor
Definition ParticleBaseUtils.hh:349
Rivet::DeltaRapInRange
(with respect to another 4-momentum, vec) in-range functor
Definition ParticleBaseUtils.hh:373
Rivet::DeltaRapLess
(with respect to another momentum, vec) less-than functor
Definition ParticleBaseUtils.hh:361
Rivet::DeltaRapWRT
Calculator of with respect to a given momentum.
Definition ParticleBaseUtils.hh:456
Rivet::DoubleParticleBaseFunctor
Base type for Particle -> double functors.
Definition ParticleBaseUtils.hh:401
Rivet::EtaGtr
Pseudorapidity greater-than functor.
Definition ParticleBaseUtils.hh:65
Rivet::EtaInRange
Pseudorapidity in-range functor.
Definition ParticleBaseUtils.hh:83
Rivet::EtaLess
Pseudorapidity less-than functor.
Definition ParticleBaseUtils.hh:74
Rivet::PtGtr
Transverse momentum greater-than functor.
Definition ParticleBaseUtils.hh:33
Rivet::PtInRange
Transverse momentum in-range functor.
Definition ParticleBaseUtils.hh:53
Rivet::PtLess
Transverse momentum less-than functor.
Definition ParticleBaseUtils.hh:43
Rivet::RapGtr
Rapidity greater-than functor.
Definition ParticleBaseUtils.hh:126
Rivet::RapInRange
Rapidity in-range functor.
Definition ParticleBaseUtils.hh:144
Rivet::RapLess
Rapidity momentum less-than functor.
Definition ParticleBaseUtils.hh:135
Generated on for Rivet by doxygen 1.15.0