27 #include "ExHEPUtils/BinnedFn.h"
28 #include "ExHEPUtils/Jet.h"
29 #include "ExHEPUtils/MathUtils.h"
30 #include "ExHEPUtils/Vectors.h"
31 #include "ExHEPUtils/Particle.h"
61 return p4.
pT2()*(1.0+p4.
m2()/p2);
64 inline double ET(P4 p4)
66 return(sqrt(
ET2(p4)));
71 return (p1->
pT() > p2->
pT());
83 return (p1->
pT() > p2->
pT());
90 if ((v1-v2).p() > 1.0)
return false;
91 if ((v1-v2).T() > 1E-3)
return false;
100 std::vector<P4*> _jet_constituents;
101 std::vector<Particle*> _particles;
102 std::vector<P4*> _neutralhadrons;
103 std::vector<Particle*> _chargedhadrons;
108 #define DELCLEAR(v) do { if (!v.empty()) for (size_t i = 0; i < v.size(); ++i) delete v[i]; v.clear(); } while (0)
109 DELCLEAR(_jet_constituents);
110 DELCLEAR(_particles);
111 DELCLEAR(_neutralhadrons);
112 DELCLEAR(_chargedhadrons);
124 void add_neutral_hadron(
double px,
double py,
double pz,
double e) {
125 P4* thad=
new P4(px, py,pz, e);
126 _neutralhadrons.push_back(thad);
129 void add_neutral_hadron(
const P4 &p4)
131 P4* thad =
new P4(p4);
132 _neutralhadrons.push_back(thad);
137 void add_charged_hadron(
double px,
double py,
double pz,
double e,
int pid) {
138 Particle* thad=
new Particle(px, py, pz, e, pid);
139 _chargedhadrons.push_back(thad);
143 void add_charged_hadron(Particle* p)
146 _chargedhadrons.push_back(p);
158 void add_jet_constituent(
double px,
double py,
double pz,
double e) {
159 P4* thad=
new P4(px, py,pz, e);
160 _jet_constituents.push_back(thad);
163 void add_jet_constituent(
const P4 &p4)
165 P4* thad =
new P4(p4);
166 _jet_constituents.push_back(thad);
170 void add_particle(Particle* p) {
171 _particles.push_back(p);
177 return _jet_constituents;
182 return _chargedhadrons;
187 return _neutralhadrons;
195 std::vector<Particle*> translate_particles(
double dz,
double dt) {
196 std::vector<Particle*> out_particles;
197 for(
auto part : _particles)
200 new_part->translate_zt(dz,dt);
201 out_particles.push_back(new_part);
203 return out_particles;
206 std::vector<Particle*> translate_charged_hadrons(
double dz,
double dt) {
207 std::vector<Particle*> out_particles;
208 for(
auto part : _chargedhadrons)
210 Particle* new_part =
new Particle(part);
211 new_part->translate_zt(dz,dt);
212 out_particles.push_back(new_part);
214 return out_particles;
235 double _centralweight;
238 std::vector<double> _weights;
242 std::vector<Particle*> _photons, _electrons, _muons, _taus, _invisibles, _HSCPs, _chargedhadrons, _neutralRhadrons;
246 mutable std::vector<Jet*> _jets;
251 std::vector<P4*> _neutralhadrons;
254 std::vector<P4*> _HCALs, _ECALs;
256 std::vector<Particle*> _charged_tracks;
261 void operator = (
const Event& e) {
263 _weights = e._weights;
264 _centralweight = e._centralweight;
265 _photons = e._photons;
266 _electrons = e._electrons;
269 _invisibles = e._invisibles;
273 _neutralhadrons = e._neutralhadrons;
274 _chargedhadrons = e._chargedhadrons;
277 _charged_tracks=e._charged_tracks;
288 #define DELCLEAR(v) do { if (!v.empty()) for (size_t i = 0; i < v.size(); ++i) delete v[i]; v.clear(); } while (0)
290 DELCLEAR(_electrons);
293 DELCLEAR(_invisibles);
296 DELCLEAR(_neutralhadrons);
297 DELCLEAR(_chargedhadrons);
309 Event(
const std::vector<Particle*>& ps,
const std::vector<double>&
weights=std::vector<double>()) {
324 void add_ECAL(
P4* p) {
329 void add_HCAL(P4* p) {
335 _charged_tracks.push_back(p);
339 const std::vector<P4*>& get_ECALs()
const {
343 const std::vector<P4*>& get_HCALs()
const {
347 const std::vector<Particle*>& get_charged_tracks()
const {
348 return _charged_tracks;
352 void add_invisible(Particle* p) {
353 _invisibles.push_back(p);
356 void add_HSCP(Particle* p) {
361 void add_neutral_hadron(
double px,
double py,
double pz,
double e) {
362 P4* thad=
new P4(px, py,pz, e);
363 _neutralhadrons.push_back(thad);
366 void add_neutral_hadron(
const P4 &p4)
368 P4* thad =
new P4(p4);
369 _neutralhadrons.push_back(thad);
372 void add_neutral_hadrons(
const std::vector<P4*> &hadrs)
374 for (
size_t i = 0; i < hadrs.size(); ++i) add_neutral_hadron(*hadrs[i]);
379 void add_charged_hadron(
double px,
double py,
double pz,
double e,
int pid) {
380 Particle* thad=
new Particle(px, py, pz, e, pid);
381 _chargedhadrons.push_back(thad);
384 void add_charged_hadron(
const P4 &p4,
int pid)
386 Particle* thad =
new Particle(p4, pid);
387 _chargedhadrons.push_back(thad);
391 void add_charged_hadron(Particle* p)
394 _chargedhadrons.push_back(p);
398 void add_charged_hadrons(
const std::vector<Particle*> &hadrs)
400 for (
size_t i = 0; i < hadrs.size(); ++i) add_charged_hadron(hadrs[i]);
417 const std::vector<Particle*>& get_charged_hadrons()
const {
418 return _chargedhadrons;
423 return _neutralhadrons;
442 e.set_weight(_centralweight);
443 const std::vector<Particle*> ps =
particles();
444 for (
size_t i = 0; i < ps.size(); ++i) {
447 const std::vector<Jet*> js =
jets();
448 for (
size_t i = 0; i < js.size(); ++i) {
475 void set_weight(
double w) {
502 if (_weights.empty()) {
503 throw std::runtime_error(
"Trying to access non-default weight from empty weight vector");
507 double weight()
const {
508 return _centralweight;
528 if(p->
abspid() == 1000024)
532 else if(p->
pid() == 1000022)
534 _invisibles.push_back(p);
560 else if (p->
pid() == 22)
561 _photons.push_back(p);
562 else if (p->
abspid() == 11)
563 _electrons.push_back(p);
564 else if (p->
abspid() == 13)
566 else if (p->
abspid() == 15)
571 else if (PDG::isInvisible(p->
abspid()))
572 _invisibles.push_back(p);
574 else if(PDG::isCharged(p->
abspid()))
585 for (
size_t i = 0; i < ps.size(); ++i)
add_particle(ps[i]);
594 std::vector<Particle*> rtn;
596 rtn.reserve(_photons.size() + _electrons.size() + _muons.size() + _taus.size() + _invisibles.size());
597 #define APPEND_VEC(vec) rtn.insert(rtn.end(), vec.begin(), vec.end())
599 APPEND_VEC(_photons);
600 APPEND_VEC(_electrons);
603 APPEND_VEC(_invisibles);
616 std::vector<Particle*> rtn;
617 rtn.reserve(_photons.size() + _electrons.size() + _muons.size() + _taus.size());
618 #define APPEND_VEC(vec) rtn.insert(rtn.end(), vec.begin(), vec.end() )
619 APPEND_VEC(_photons);
620 APPEND_VEC(_electrons);
631 const std::vector<Particle*>&
HSCPs()
const {
661 const std::vector<Particle*>&
muons()
const {
671 const std::vector<Particle*>&
taus()
const {
675 std::vector<Particle*>&
taus() {
681 const std::vector<Particle*>&
photons()
const {
695 const std::vector<Jet*>&
jets()
const {
696 std::sort(_jets.begin(), _jets.end(),
_cmpPtDesc);
702 std::sort(_jets.begin(), _jets.end(),
_cmpPtDesc);
Simple event class, separating particles into classes.
Definition: heputil.h:227
void add_particles(const std::vector< Particle * > &ps)
Definition: heputil.h:584
double met() const
Get the missing transverse momentum in GeV.
Definition: heputil.h:741
const std::vector< Particle * > & HSCPs() const
Get invisible final state particles.
Definition: heputil.h:631
std::vector< Particle * > visible_particles() const
Definition: heputil.h:614
void set_missingmom(const P4 &pmiss)
Set the missing momentum vector.
Definition: heputil.h:736
Event()
Default constructor.
Definition: heputil.h:306
const std::vector< Particle * > & invisible_particles() const
Get invisible final state particles.
Definition: heputil.h:641
const std::vector< Particle * > & muons() const
Get prompt muons.
Definition: heputil.h:661
std::vector< Particle * > & photons()
Get prompt photons (non-const)
Definition: heputil.h:685
const std::vector< Particle * > & photons() const
Get prompt photons.
Definition: heputil.h:681
std::vector< Particle * > & HSCPs()
Get invisible final state particles (non-const)
Definition: heputil.h:635
const std::vector< Particle * > & electrons() const
Get prompt electrons.
Definition: heputil.h:651
const std::vector< double > & weights() const
Get the event weights (const)
Definition: heputil.h:480
std::vector< Particle * > & electrons()
Get prompt electrons (non-const)
Definition: heputil.h:655
std::vector< double > & weights()
Get the event weights (non-const)
Definition: heputil.h:485
~Event()
Destructor (cleans up all passed Particles and calculated Jets)
Definition: heputil.h:316
const std::vector< Particle * > & taus() const
Get prompt (hadronic) taus.
Definition: heputil.h:671
void add_particle(Particle *p)
Definition: heputil.h:523
std::vector< Particle * > & invisible_particles()
Get invisible final state particles (non-const)
Definition: heputil.h:645
void cloneTo(Event &e) const
Clone a deep copy (new Particles and Jets allocated) into the provided event object.
Definition: heputil.h:440
Event(const std::vector< Particle * > &ps, const std::vector< double > &weights=std::vector< double >())
Constructor from a list of Particles, I don't use it.
Definition: heputil.h:309
const std::vector< Jet * > & jets() const
Get anti-kT 0.4 jets (not including charged leptons or photons)
Definition: heputil.h:695
double weight(size_t i) const
Get a single event weight – the nominal, by default.
Definition: heputil.h:501
void set_weights(const std::vector< double > &ws)
Set the event weights (also possible directly via non-const reference)
Definition: heputil.h:461
std::vector< Particle * > particles() const
Definition: heputil.h:592
void add_jet(Jet *j)
Add a jet to the jets collection.
Definition: heputil.h:716
void clear()
Empty the event's particle, jet and MET collections.
Definition: heputil.h:284
const std::vector< P4 * > & get_neutral_hadrons() const
Get prompt electrons.
Definition: heputil.h:422
void set_jets(const std::vector< Jet * > &jets)
Set the jets collection.
Definition: heputil.h:709
void cloneTo(Event *e) const
Clone a deep copy (new Particles and Jets allocated) into the provided event pointer.
Definition: heputil.h:434
Event * clone() const
Clone a copy on the heap.
Definition: heputil.h:427
std::vector< Particle * > & taus()
Get prompt (hadronic) taus (non-const)
Definition: heputil.h:675
std::vector< Particle * > & muons()
Get prompt muons (non-const)
Definition: heputil.h:665
const P4 & missingmom() const
Get the missing momentum vector.
Definition: heputil.h:729
std::vector< Jet * > & jets()
Get anti-kT 0.4 jets (not including charged leptons or photons) (non-const)
Definition: heputil.h:701
double pT() const
Get the squared transverse momentum.
Definition: Jet.h:96
A 4-momentum class for vectors.
Definition: Vectors.h:45
double p2() const
Get E^2.
Definition: Vectors.h:441
double m2() const
Get m^2.
Definition: Vectors.h:408
double pT() const
Get the transverse momentum (same as rho)
Definition: Vectors.h:453
double pT2() const
Get the transverse momentum squared (same as rho2)
Definition: Vectors.h:451
void clear()
Set the components to zero.
Definition: Vectors.h:82
Definition: Particle.h:24
int pid() const
Get PDG ID code.
Definition: Particle.h:187
int abspid() const
Get abs PDG ID code.
Definition: Particle.h:189
double pT() const
Get the squared transverse momentum.
Definition: Particle.h:165
bool is_prompt() const
Is this particle connected to the hard process or from a hadron/tau decay?
Definition: Particle.h:176
~PileupEvent()
Destructor (cleans up all passed Particles and calculated Jets)
Definition: heputil.h:119
const std::vector< Particle * > & get_charged_hadrons() const
Get charged hadrons.
Definition: heputil.h:181
PileupEvent()
Default constructor.
Definition: heputil.h:116
const std::vector< P4 * > & get_jet_constituents() const
Get jet constituents.
Definition: heputil.h:176
const std::vector< Particle * > & get_particles() const
Get particles.
Definition: heputil.h:191
const std::vector< P4 * > & get_neutral_hadrons() const
Get neutral hadrons.
Definition: heputil.h:186
Modified by Mark Goodsell goodsell@lpthe.jussieu.fr
Definition: ATLAS_SUSY_2018_16.cc:27
double ET2(P4 p4)
Definition: heputil.h:52
bool _cmpPtDesc(const Jet *a, const Jet *b)
Function/functor for container<const Jet*> sorting (cf. std::less)
Definition: Jet.h:123