Fork me on GitHub

source: git/classes/DelphesClasses.h @ 666d795

ImprovedOutputFileTimingdual_readoutllp
Last change on this file since 666d795 was 666d795, checked in by Michele Selvaggi <michele.selvaggi@…>, 6 years ago

replaced N-sub by array in Jet class (same as in Candidate class)

  • Property mode set to 100644
File size: 14.6 KB
Line 
1/*
2 *  Delphes: a framework for fast simulation of a generic collider experiment
3 *  Copyright (C) 2012-2014  Universite catholique de Louvain (UCL), Belgium
4 *
5 *  This program is free software: you can redistribute it and/or modify
6 *  it under the terms of the GNU General Public License as published by
7 *  the Free Software Foundation, either version 3 of the License, or
8 *  (at your option) any later version.
9 *
10 *  This program is distributed in the hope that it will be useful,
11 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 *  GNU General Public License for more details.
14 *
15 *  You should have received a copy of the GNU General Public License
16 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 */
18
19#ifndef DelphesClasses_h
20#define DelphesClasses_h
21
22/**
23 *
24 *  Definition of classes to be stored in the root tree.
25 *  Function CompareXYZ sorts objects by the variable XYZ that MUST be
26 *  present in the data members of the root tree class of the branch.
27 *
28 *  \author P. Demin - UCL, Louvain-la-Neuve
29 *
30 */
31
32// Dependencies (#includes)
33
34#include "TRef.h"
35#include "TObject.h"
36#include "TRefArray.h"
37#include "TLorentzVector.h"
38
39#include "classes/SortableObject.h"
40
41class DelphesFactory;
42
43//---------------------------------------------------------------------------
44
45class Event: public TObject
46{
47public:
48
49  Long64_t Number; // event number
50
51  Float_t ReadTime;
52  Float_t ProcTime;
53
54  ClassDef(Event, 1)
55};
56
57//---------------------------------------------------------------------------
58
59class LHCOEvent: public Event
60{
61public:
62
63  Int_t Trigger; // trigger word
64
65  ClassDef(LHCOEvent, 1)
66};
67
68//---------------------------------------------------------------------------
69
70class LHEFEvent: public Event
71{
72public:
73
74  Int_t ProcessID; // subprocess code for the event | hepup.IDPRUP
75
76  Float_t Weight; // weight for the event | hepup.XWGTUP
77  Float_t ScalePDF; // scale in GeV used in the calculation of the PDFs in the event | hepup.SCALUP
78  Float_t AlphaQED; // value of the QED coupling used in the event | hepup.AQEDUP
79  Float_t AlphaQCD; // value of the QCD coupling used in the event | hepup.AQCDUP
80
81  ClassDef(LHEFEvent, 2)
82};
83
84//---------------------------------------------------------------------------
85
86class HepMCEvent: public Event
87{
88public:
89
90  Int_t ProcessID; // unique signal process id | signal_process_id()
91  Int_t MPI; // number of multi parton interactions | mpi ()
92
93  Float_t Weight; // weight for the event
94
95  Float_t Scale; // energy scale, see hep-ph/0109068 | event_scale()
96  Float_t AlphaQED; // QED coupling, see hep-ph/0109068 | alphaQED()
97  Float_t AlphaQCD; // QCD coupling, see hep-ph/0109068 | alphaQCD()
98
99  Int_t ID1; // flavour code of first parton | pdf_info()->id1()
100  Int_t ID2; // flavour code of second parton | pdf_info()->id2()
101
102  Float_t X1; // fraction of beam momentum carried by first parton ("beam side") | pdf_info()->x1()
103  Float_t X2; // fraction of beam momentum carried by second parton ("target side") | pdf_info()->x2()
104
105  Float_t ScalePDF; // Q-scale used in evaluation of PDF's (in GeV) | pdf_info()->scalePDF()
106
107  Float_t PDF1; // PDF (id1, x1, Q) | pdf_info()->pdf1()
108  Float_t PDF2; // PDF (id2, x2, Q) | pdf_info()->pdf2()
109
110  ClassDef(HepMCEvent, 2)
111};
112
113//---------------------------------------------------------------------------
114
115class GenParticle: public SortableObject
116{
117public:
118  Int_t PID; // particle HEP ID number | hepevt.idhep[number]
119
120  Int_t Status; // particle status | hepevt.isthep[number]
121  Int_t IsPU; // 0 or 1 for particles from pile-up interactions
122
123  Int_t M1; // particle 1st mother | hepevt.jmohep[number][0] - 1
124  Int_t M2; // particle 2nd mother | hepevt.jmohep[number][1] - 1
125
126  Int_t D1; // particle 1st daughter | hepevt.jdahep[number][0] - 1
127  Int_t D2; // particle last daughter | hepevt.jdahep[number][1] - 1
128
129  Int_t Charge; // particle charge
130
131  Float_t Mass; // particle mass
132
133  Float_t E; // particle energy | hepevt.phep[number][3]
134  Float_t Px; // particle momentum vector (x component) | hepevt.phep[number][0]
135  Float_t Py; // particle momentum vector (y component) | hepevt.phep[number][1]
136  Float_t Pz; // particle momentum vector (z component) | hepevt.phep[number][2]
137
138  Float_t PT; // particle transverse momentum
139  Float_t Eta; // particle pseudorapidity
140  Float_t Phi; // particle azimuthal angle
141
142  Float_t Rapidity; // particle rapidity
143
144  Float_t T; // particle vertex position (t component) | hepevt.vhep[number][3]
145  Float_t X; // particle vertex position (x component) | hepevt.vhep[number][0]
146  Float_t Y; // particle vertex position (y component) | hepevt.vhep[number][1]
147  Float_t Z; // particle vertex position (z component) | hepevt.vhep[number][2]
148
149  static CompBase *fgCompare; //!
150  const CompBase *GetCompare() const { return fgCompare; }
151
152  TLorentzVector P4();
153
154  ClassDef(GenParticle, 1)
155};
156
157//---------------------------------------------------------------------------
158
159class Vertex: public TObject
160{
161public:
162  Float_t T; // vertex position (t component)
163  Float_t X; // vertex position (x component)
164  Float_t Y; // vertex position (y component)
165  Float_t Z; // vertex position (z component)
166
167  ClassDef(Vertex, 1)
168};
169
170//---------------------------------------------------------------------------
171
172class MissingET: public TObject
173{
174public:
175  Float_t MET; // mising transverse energy
176  Float_t Eta; // mising energy pseudorapidity
177  Float_t Phi; // mising energy azimuthal angle
178
179  TLorentzVector P4();
180
181  ClassDef(MissingET, 1)
182};
183
184//---------------------------------------------------------------------------
185
186class ScalarHT: public TObject
187{
188public:
189  Float_t HT; // scalar sum of transverse momenta
190
191  ClassDef(ScalarHT, 1)
192};
193
194//---------------------------------------------------------------------------
195
196class Rho: public TObject
197{
198public:
199  Float_t Rho; // rho energy density
200  Float_t Edges[2]; // pseudorapidity range edges
201
202  ClassDef(Rho, 1)
203};
204
205//---------------------------------------------------------------------------
206
207class Weight: public TObject
208{
209public:
210  Float_t Weight; // weight for the event
211
212  ClassDef(Weight, 1)
213};
214
215//---------------------------------------------------------------------------
216
217class Photon: public SortableObject
218{
219public:
220
221  Float_t PT; // photon transverse momentum
222  Float_t Eta; // photon pseudorapidity
223  Float_t Phi; // photon azimuthal angle
224
225  Float_t E; // photon energy
226
227  Float_t T; //particle arrival time of flight
228
229  Float_t EhadOverEem; // ratio of the hadronic versus electromagnetic energy deposited in the calorimeter
230
231  TRefArray Particles; // references to generated particles
232
233  // Isolation variables
234 
235  Float_t IsolationVar;
236  Float_t IsolationVarRhoCorr;
237  Float_t SumPtCharged;
238  Float_t SumPtNeutral;
239  Float_t SumPtChargedPU;
240  Float_t SumPt;
241
242  static CompBase *fgCompare; //!
243  const CompBase *GetCompare() const { return fgCompare; }
244
245  TLorentzVector P4();
246
247  ClassDef(Photon, 2)
248};
249
250//---------------------------------------------------------------------------
251
252class Electron: public SortableObject
253{
254public:
255
256  Float_t PT; // electron transverse momentum
257  Float_t Eta; // electron pseudorapidity
258  Float_t Phi; // electron azimuthal angle
259
260  Float_t T; //particle arrival time of flight
261
262  Int_t Charge; // electron charge
263
264  Float_t EhadOverEem; // ratio of the hadronic versus electromagnetic energy deposited in the calorimeter
265
266  TRef Particle; // reference to generated particle
267
268  // Isolation variables
269 
270  Float_t IsolationVar;
271  Float_t IsolationVarRhoCorr;
272  Float_t SumPtCharged;
273  Float_t SumPtNeutral;
274  Float_t SumPtChargedPU;
275  Float_t SumPt;
276
277  static CompBase *fgCompare; //!
278  const CompBase *GetCompare() const { return fgCompare; }
279
280  TLorentzVector P4();
281
282  ClassDef(Electron, 2)
283};
284
285//---------------------------------------------------------------------------
286
287class Muon: public SortableObject
288{
289public:
290
291  Float_t PT; // muon transverse momentum
292  Float_t Eta; // muon pseudorapidity
293  Float_t Phi; // muon azimuthal angle
294
295  Float_t T; //particle arrival time of flight
296
297  Int_t Charge; // muon charge
298
299  TRef Particle; // reference to generated particle
300
301   // Isolation variables
302 
303  Float_t IsolationVar;
304  Float_t IsolationVarRhoCorr;
305  Float_t SumPtCharged;
306  Float_t SumPtNeutral;
307  Float_t SumPtChargedPU;
308  Float_t SumPt;
309
310  static CompBase *fgCompare; //!
311  const CompBase *GetCompare() const { return fgCompare; }
312
313  TLorentzVector P4();
314
315  ClassDef(Muon, 2)
316};
317
318//---------------------------------------------------------------------------
319
320class Jet: public SortableObject
321{
322public:
323
324  Float_t PT; // jet transverse momentum
325  Float_t Eta; // jet pseudorapidity
326  Float_t Phi; // jet azimuthal angle
327
328  Float_t T; //particle arrival time of flight
329
330  Float_t Mass; // jet invariant mass
331
332  Float_t DeltaEta;  // jet radius in pseudorapidity
333  Float_t DeltaPhi;  // jet radius in azimuthal angle
334
335  UInt_t BTag; // 0 or 1 for a jet that has been tagged as containing a heavy quark
336  UInt_t TauTag; // 0 or 1 for a jet that has been tagged as a tau
337
338  Int_t Charge; // tau charge
339
340  Float_t EhadOverEem; // ratio of the hadronic versus electromagnetic energy deposited in the calorimeter
341
342  Int_t    NCharged; // number of charged constituents
343  Int_t    NNeutrals; // number of neutral constituents
344  Float_t  Beta; // (sum pt of charged pile-up constituents)/(sum pt of charged constituents)
345  Float_t  BetaStar; // (sum pt of charged constituents coming from hard interaction)/(sum pt of charged constituents)
346  Float_t  MeanSqDeltaR; // average distance (squared) between constituent and jet weighted by pt (squared) of constituent
347  Float_t  PTD; // average pt between constituent and jet weighted by pt of constituent
348  Float_t  FracPt[5]; // (sum pt of constituents within a ring 0.1*i < DeltaR < 0.1*(i+1))/(sum pt of constituents)
349
350  Float_t Tau[5]; // N-subjettiness
351 
352  TRefArray Constituents; // references to constituents
353  TRefArray Particles; // references to generated particles
354
355  static CompBase *fgCompare; //!
356  const CompBase *GetCompare() const { return fgCompare; }
357
358  TLorentzVector P4();
359  TLorentzVector Area;
360
361  ClassDef(Jet, 3)
362};
363
364//---------------------------------------------------------------------------
365
366class Track: public SortableObject
367{
368public:
369  Int_t PID; // HEP ID number
370
371  Int_t Charge; // track charge
372
373  Float_t PT; // track transverse momentum
374
375  Float_t Eta; // track pseudorapidity
376  Float_t Phi; // track azimuthal angle
377
378  Float_t EtaOuter; // track pseudorapidity at the tracker edge
379  Float_t PhiOuter; // track azimuthal angle at the tracker edge
380
381  Float_t X; // track vertex position (x component)
382  Float_t Y; // track vertex position (y component)
383  Float_t Z; // track vertex position (z component)
384  Float_t T; // track vertex position (z component)
385
386  Float_t XOuter; // track position (x component) at the tracker edge
387  Float_t YOuter; // track position (y component) at the tracker edge
388  Float_t ZOuter; // track position (z component) at the tracker edge
389  Float_t TOuter; // track position (z component) at the tracker edge
390
391  Float_t Dxy;     // track signed transverse impact parameter
392  Float_t SDxy;    // signed error on the track signed transverse impact parameter
393  Float_t Xd;      // X coordinate of point of closest approach to vertex
394  Float_t Yd;      // Y coordinate of point of closest approach to vertex
395  Float_t Zd;      // Z coordinate of point of closest approach to vertex
396
397  TRef Particle; // reference to generated particle
398
399  static CompBase *fgCompare; //!
400  const CompBase *GetCompare() const { return fgCompare; }
401
402  TLorentzVector P4();
403
404  ClassDef(Track, 2)
405};
406
407//---------------------------------------------------------------------------
408
409class Tower: public SortableObject
410{
411public:
412  Float_t ET; // calorimeter tower transverse energy
413  Float_t Eta; // calorimeter tower pseudorapidity
414  Float_t Phi; // calorimeter tower azimuthal angle
415
416  Float_t E; // calorimeter tower energy
417
418  Float_t T; // ecal deposit time, averaged by sqrt(EM energy) over all particles, not smeared
419  Int_t   Ntimes; // number of hits contributing to time measurement
420 
421  Float_t Eem; // calorimeter tower electromagnetic energy
422  Float_t Ehad; // calorimeter tower hadronic energy
423
424  Float_t Edges[4]; // calorimeter tower edges
425
426  TRefArray Particles; // references to generated particles
427
428  static CompBase *fgCompare; //!
429  const CompBase *GetCompare() const { return fgCompare; }
430
431  TLorentzVector P4();
432
433  ClassDef(Tower, 1)
434};
435
436//---------------------------------------------------------------------------
437
438class HectorHit: public SortableObject
439{
440public:
441  Float_t E; // reconstructed energy [GeV]
442
443  Float_t Tx; // angle of the momentum in the horizontal (x,z) plane [urad]
444  Float_t Ty; // angle of the momentum in the verical (y,z) plane [urad]
445
446  Float_t T; // time of flight to the detector [s]
447
448  Float_t X; // horizontal distance to the beam [um]
449  Float_t Y; // vertical distance to the beam [um]
450  Float_t S; // distance to the interaction point [m]
451
452  TRef Particle; // reference to generated particle
453
454  static CompBase *fgCompare; //!
455  const CompBase *GetCompare() const { return fgCompare; }
456
457  ClassDef(HectorHit, 1)
458};
459
460//---------------------------------------------------------------------------
461
462class Candidate: public SortableObject
463{
464  friend class DelphesFactory;
465
466public:
467  Candidate();
468
469  Int_t PID;
470
471  Int_t Status;
472  Int_t M1, M2, D1, D2;
473
474  Int_t Charge;
475
476  Float_t Mass;
477
478  Int_t IsPU;
479  Int_t IsRecoPU;
480 
481  Int_t IsConstituent;
482
483  UInt_t BTag;
484  UInt_t TauTag;
485
486  Float_t Eem;
487  Float_t Ehad;
488
489  Float_t Edges[4];
490  Float_t DeltaEta;
491  Float_t DeltaPhi;
492
493  TLorentzVector Momentum, Position, Area;
494
495  Float_t  Dxy;
496  Float_t  SDxy;
497  Float_t  Xd;
498  Float_t  Yd;
499  Float_t  Zd;
500
501  // PileUpJetID variables
502
503  Int_t    NCharged;
504  Int_t    NNeutrals;
505  Float_t  Beta;
506  Float_t  BetaStar;
507  Float_t  MeanSqDeltaR;
508  Float_t  PTD;
509  Float_t  FracPt[5];
510 
511  //Timing information
512 
513  Int_t    Ntimes;
514  std::vector<std::pair<Float_t,Float_t> > Ecal_E_t;
515
516  // Isolation variables
517 
518  Float_t IsolationVar;
519  Float_t IsolationVarRhoCorr;
520  Float_t SumPtCharged;
521  Float_t SumPtNeutral;
522  Float_t SumPtChargedPU;
523  Float_t SumPt;
524
525  // N-subjettiness variables
526
527  Float_t Tau[5];
528 
529 
530 
531
532  static CompBase *fgCompare; //!
533  const CompBase *GetCompare() const { return fgCompare; }
534
535  void AddCandidate(Candidate *object);
536  TObjArray *GetCandidates();
537
538  Bool_t Overlaps(const Candidate *object) const;
539
540  virtual void Copy(TObject &object) const;
541  virtual TObject *Clone(const char *newname = "") const;
542  virtual void Clear(Option_t* option = "");
543
544private:
545  DelphesFactory *fFactory; //!
546  TObjArray *fArray; //!
547
548  void SetFactory(DelphesFactory *factory) { fFactory = factory; }
549
550  ClassDef(Candidate, 2)
551};
552
553#endif // DelphesClasses_h
554
555
Note: See TracBrowser for help on using the repository browser.