| 1 |
#ifndef _kinematics_h_
|
| 2 |
#define _kinematics_h_
|
| 3 |
|
| 4 |
#include "TObject.h"
|
| 5 |
#include "TLorentzVector.h"
|
| 6 |
#include "TClonesArray.h"
|
| 7 |
#include "TVector3.h"
|
| 8 |
|
| 9 |
#define L1EMOBJ 0x1
|
| 10 |
#define L1JETOBJ 0x2
|
| 11 |
#define L1MUONOBJ 0x4
|
| 12 |
#define L1OTHEROBJ 0x8
|
| 13 |
#define MAXL1TRIGGERBITS 256
|
| 14 |
|
| 15 |
#define MAX_TRIG_WORD 4
|
| 16 |
|
| 17 |
#define EDM_MAX_LENGTH 0x4
|
| 18 |
|
| 19 |
#define CALOJET 0
|
| 20 |
#define JPTJET 1
|
| 21 |
#define PFJET 2
|
| 22 |
|
| 23 |
#define PDG_ID_ELECTRON 11
|
| 24 |
#define PDG_ID_MUON 13
|
| 25 |
#define ANY_TRACK -999
|
| 26 |
|
| 27 |
class _mc_process_ : public TObject {
|
| 28 |
|
| 29 |
|
| 30 |
public:
|
| 31 |
|
| 32 |
// event information
|
| 33 |
Int_t mpi, processId, eventNumber;
|
| 34 |
Int_t vtxBarcode;
|
| 35 |
Float_t eventScale, alphaQCD, alphaQED;
|
| 36 |
|
| 37 |
|
| 38 |
|
| 39 |
|
| 40 |
// PDF information
|
| 41 |
Float_t x1, x2;
|
| 42 |
Int_t flav1, flav2;
|
| 43 |
Float_t xfx1, xfx2;
|
| 44 |
Float_t scalePDF; // Q valued used in PDF evolution.
|
| 45 |
|
| 46 |
|
| 47 |
// vector boson information
|
| 48 |
Int_t decayType, bosId;
|
| 49 |
Float_t bosPt, bosPz, bosMass, bosEta, bosPhi, bosRap;
|
| 50 |
|
| 51 |
Float_t dileptonPt, dileptonPz, dileptonMass, dileptonEta, dileptonPhi, dileptonRap;
|
| 52 |
Float_t cosTheta; // simple two-body decay angle
|
| 53 |
Float_t cosPhi;
|
| 54 |
Float_t nphotons;
|
| 55 |
|
| 56 |
|
| 57 |
// vector boson daughters
|
| 58 |
Float_t muonEnergy, muonPt, muonPz, muonEta, muonPhi, muonId; // particle
|
| 59 |
Float_t muonBarEnergy, muonBarPt, muonBarPz, muonBarEta, muonBarPhi, muonBarId; // anti particle
|
| 60 |
|
| 61 |
Float_t nrmuonEnergy, nrmuonPt, nrmuonPz, nrmuonEta, nrmuonPhi, nrmuonId; // particle
|
| 62 |
Float_t nrmuonBarEnergy, nrmuonBarPt, nrmuonBarPz, nrmuonBarEta, nrmuonBarPhi, nrmuonBarId; // anti particle
|
| 63 |
|
| 64 |
Float_t photonEnergy, photonPhi, photonEta, photonAngle;
|
| 65 |
|
| 66 |
|
| 67 |
// Z/gamma process
|
| 68 |
Float_t cosThetaCS, sin2ThetaCS, tanPhiCS;
|
| 69 |
Float_t corCosThetaCS, corSin2ThetaCS, corTanPhiCS;
|
| 70 |
Int_t sameSign;
|
| 71 |
Float_t qqbar, qbarq, mistag;
|
| 72 |
|
| 73 |
|
| 74 |
// W production
|
| 75 |
Float_t metX, metY, delta, fprob, bprob;
|
| 76 |
|
| 77 |
_mc_process_() {}
|
| 78 |
_mc_process_(const _mc_process_ & orig);
|
| 79 |
virtual ~_mc_process_() {Clear();}
|
| 80 |
void Initialize();
|
| 81 |
|
| 82 |
|
| 83 |
ClassDef(_mc_process_, 2)
|
| 84 |
};
|
| 85 |
|
| 86 |
// For WZ signal MC
|
| 87 |
class _genwz_ : public TObject {
|
| 88 |
|
| 89 |
|
| 90 |
public:
|
| 91 |
|
| 92 |
// Z Boson Information
|
| 93 |
Int_t Z_decayType, Z_bosId;
|
| 94 |
Float_t Z_bosPt, Z_bosPz, Z_bosMass, Z_bosEta, Z_bosPhi, Z_bosRap;
|
| 95 |
Float_t Z_dauAEnergy, Z_dauAPt, Z_dauAPz, Z_dauAEta, Z_dauAPhi, Z_dauAId; // particle
|
| 96 |
Float_t Z_dauBEnergy, Z_dauBPt, Z_dauBPz, Z_dauBEta, Z_dauBPhi, Z_dauBId; // anti particle
|
| 97 |
Float_t Z_dileptonPt, Z_dileptonPz, Z_dileptonMass, Z_dileptonEta, Z_dileptonPhi, Z_dileptonRap;
|
| 98 |
Float_t Z_cosTheta; // simple two-body decay angle
|
| 99 |
Float_t Z_cosPhi;
|
| 100 |
Float_t Z_nphotons,Z_phoEnergy, Z_phoPhi, Z_phoEta, Z_phoAngle;
|
| 101 |
|
| 102 |
// W Boson Information
|
| 103 |
Int_t W_decayType, W_bosId;
|
| 104 |
Float_t W_bosPt, W_bosPz, W_bosMass, W_bosEta, W_bosPhi, W_bosRap;
|
| 105 |
Float_t W_dauAEnergy, W_dauAPt, W_dauAPz, W_dauAEta, W_dauAPhi, W_dauAId; // particle
|
| 106 |
Float_t W_dauBEnergy, W_dauBPt, W_dauBPz, W_dauBEta, W_dauBPhi, W_dauBId; // anti particle
|
| 107 |
Float_t W_dileptonPt, W_dileptonPz, W_dileptonMass, W_dileptonEta, W_dileptonPhi, W_dileptonRap;
|
| 108 |
Float_t W_cosTheta; // simple two-body decay angle
|
| 109 |
Float_t W_cosPhi;
|
| 110 |
Float_t W_nphotons,W_phoEnergy, W_phoPhi, W_phoEta, W_phoAngle;
|
| 111 |
|
| 112 |
// WZ System
|
| 113 |
Int_t gdWZ;
|
| 114 |
Float_t WZ_Pt, WZ_Pz, WZ_Mass, WZ_Eta, WZ_Phi, WZ_Rap, WZ_cosAngZ, WZ_cosAngW;
|
| 115 |
|
| 116 |
_genwz_() {}
|
| 117 |
_genwz_(const _genwz_ & orig);
|
| 118 |
virtual ~_genwz_() {Clear();}
|
| 119 |
void Initialize();
|
| 120 |
|
| 121 |
|
| 122 |
ClassDef(_genwz_, 2)
|
| 123 |
};
|
| 124 |
|
| 125 |
|
| 126 |
class _vec4_ : public TObject {
|
| 127 |
|
| 128 |
public:
|
| 129 |
|
| 130 |
Float_t id;
|
| 131 |
Float_t pt;
|
| 132 |
Float_t eta;
|
| 133 |
Float_t phi;
|
| 134 |
|
| 135 |
|
| 136 |
_vec4_();
|
| 137 |
_vec4_(const _vec4_ & orig);
|
| 138 |
virtual ~_vec4_();
|
| 139 |
|
| 140 |
|
| 141 |
ClassDef(_vec4_, 2)
|
| 142 |
};
|
| 143 |
|
| 144 |
|
| 145 |
class _met_ : public _vec4_ {
|
| 146 |
|
| 147 |
public:
|
| 148 |
|
| 149 |
|
| 150 |
Float_t sumEt, e_longitudinal;
|
| 151 |
Float_t HadronicEtFraction, EMEtFraction;
|
| 152 |
Float_t MuonEtFraction, InvisibleEtFraction;
|
| 153 |
|
| 154 |
|
| 155 |
|
| 156 |
|
| 157 |
_met_();
|
| 158 |
_met_(const _met_ & orig);
|
| 159 |
virtual ~_met_();
|
| 160 |
|
| 161 |
|
| 162 |
ClassDef(_met_, 2)
|
| 163 |
|
| 164 |
};
|
| 165 |
|
| 166 |
class _track_ : public TObject{
|
| 167 |
|
| 168 |
public:
|
| 169 |
|
| 170 |
|
| 171 |
Int_t vertexIndex;
|
| 172 |
Float_t closestVertexDist;
|
| 173 |
|
| 174 |
|
| 175 |
Float_t chi2, normalizedChi2, charge, ndof;
|
| 176 |
|
| 177 |
Float_t pt, eta, phi;
|
| 178 |
Float_t ptError, etaError, phiError;
|
| 179 |
|
| 180 |
|
| 181 |
Float_t qoverp, qoverpError;
|
| 182 |
Float_t lambda, lambdaError;
|
| 183 |
|
| 184 |
Float_t dxy0, dxy0Error;
|
| 185 |
Float_t dz0, dz0Error;
|
| 186 |
Float_t dsz0, dsz0Error;
|
| 187 |
|
| 188 |
Float_t dxy;
|
| 189 |
Float_t dz;
|
| 190 |
Float_t dsz;
|
| 191 |
|
| 192 |
|
| 193 |
Int_t recHitsSize, numberOfValidHits, outerOk;
|
| 194 |
Int_t nStereoHits;
|
| 195 |
Float_t outerRadius, innerRadius;
|
| 196 |
|
| 197 |
Int_t numberOfValidPixelHits, numberOfValidStripHits, numberOfValidPixelBarrelHits;
|
| 198 |
Int_t pixelLayersWithMeasurement, pixelBarrelLayersWithMeasurement, pixelEndcapLayersWithMeasurement;
|
| 199 |
|
| 200 |
Int_t hasValidHitInFirstPixelBarrel;
|
| 201 |
Int_t trackerExpectedHitsInner_numberOfHits;
|
| 202 |
|
| 203 |
Int_t mcType;
|
| 204 |
Float_t mcPt, mcEta, mcPhi;
|
| 205 |
|
| 206 |
_track_();
|
| 207 |
_track_(const _track_ & orig);
|
| 208 |
virtual ~_track_();
|
| 209 |
|
| 210 |
|
| 211 |
ClassDef(_track_, 2)
|
| 212 |
};
|
| 213 |
|
| 214 |
|
| 215 |
|
| 216 |
class _trg_bits_ : public TObject {
|
| 217 |
|
| 218 |
public:
|
| 219 |
|
| 220 |
ULong_t l1TrgBits [MAX_TRIG_WORD];
|
| 221 |
ULong_t l1tTrgBits [MAX_TRIG_WORD];
|
| 222 |
ULong_t hltAccTrgBits[MAX_TRIG_WORD];
|
| 223 |
ULong_t hltRunTrgBits[MAX_TRIG_WORD];
|
| 224 |
ULong_t hltErrTrgBits[MAX_TRIG_WORD];
|
| 225 |
|
| 226 |
_trg_bits_();
|
| 227 |
_trg_bits_(const _trg_bits_ & orig);
|
| 228 |
virtual ~_trg_bits_();
|
| 229 |
|
| 230 |
|
| 231 |
void setL1TrgBits(ULong_t *bits);
|
| 232 |
void setL1TTrgBits(ULong_t *bits);
|
| 233 |
void setHLTAccTrgBits(ULong_t *bits);
|
| 234 |
void setHLTRunTrgBits(ULong_t *bits);
|
| 235 |
void setHLTErrTrgBits(ULong_t *bits);
|
| 236 |
|
| 237 |
|
| 238 |
ClassDef(_trg_bits_, 2)
|
| 239 |
};
|
| 240 |
|
| 241 |
|
| 242 |
class _hlt_info_ : public TObject {
|
| 243 |
|
| 244 |
public:
|
| 245 |
|
| 246 |
|
| 247 |
Bool_t HLT_Muon;
|
| 248 |
Bool_t HLT_MuonL;
|
| 249 |
Bool_t HLT_Electron;
|
| 250 |
Bool_t HLT_ElectronL;
|
| 251 |
|
| 252 |
|
| 253 |
|
| 254 |
_hlt_info_();
|
| 255 |
_hlt_info_(const _hlt_info_ & orig);
|
| 256 |
virtual ~_hlt_info_();
|
| 257 |
|
| 258 |
ClassDef(_hlt_info_, 2)
|
| 259 |
};
|
| 260 |
|
| 261 |
|
| 262 |
class _mets_ : public TObject {
|
| 263 |
|
| 264 |
public:
|
| 265 |
|
| 266 |
|
| 267 |
_met_ caloMET, tcMET, pfMET, muonJESCorSC5MET, genMET, rawMET;
|
| 268 |
|
| 269 |
|
| 270 |
_mets_();
|
| 271 |
_mets_(const _mets_ & orig);
|
| 272 |
virtual ~_mets_();
|
| 273 |
|
| 274 |
ClassDef(_mets_, 2)
|
| 275 |
};
|
| 276 |
|
| 277 |
class _dileadingjets_ : public TObject {
|
| 278 |
|
| 279 |
public:
|
| 280 |
|
| 281 |
Int_t charge;
|
| 282 |
Int_t daughtA, daughtB;
|
| 283 |
Int_t daughtAType, daughtBType;
|
| 284 |
|
| 285 |
// the composite particle
|
| 286 |
// Float_t px, py, pz, p0;
|
| 287 |
Float_t pt, eta, phi;
|
| 288 |
Float_t ptx, pty;
|
| 289 |
Float_t rapidity;
|
| 290 |
Float_t mass;
|
| 291 |
|
| 292 |
_dileadingjets_();
|
| 293 |
_dileadingjets_(const _dileadingjets_ & orig);
|
| 294 |
virtual ~_dileadingjets_();
|
| 295 |
void Initialize();
|
| 296 |
|
| 297 |
ClassDef(_dileadingjets_, 2)
|
| 298 |
};
|
| 299 |
|
| 300 |
|
| 301 |
|
| 302 |
|
| 303 |
class _run_info_ : public TObject {
|
| 304 |
|
| 305 |
public:
|
| 306 |
|
| 307 |
Float_t autoXSec;
|
| 308 |
Float_t extXsec;
|
| 309 |
Float_t filterEff;
|
| 310 |
|
| 311 |
_run_info_();
|
| 312 |
_run_info_(const _run_info_ & orig);
|
| 313 |
virtual ~_run_info_();
|
| 314 |
|
| 315 |
ClassDef(_run_info_, 2)
|
| 316 |
};
|
| 317 |
|
| 318 |
class _vertex_ : public TObject {
|
| 319 |
|
| 320 |
public:
|
| 321 |
|
| 322 |
Int_t isValid, isFake;
|
| 323 |
Float_t x, y, z;
|
| 324 |
Float_t xError, yError, zError;
|
| 325 |
Float_t chi2, ndof, tracksSize, normalizedChi2;
|
| 326 |
|
| 327 |
_vertex_();
|
| 328 |
_vertex_(const _vertex_ & orig);
|
| 329 |
virtual ~_vertex_();
|
| 330 |
|
| 331 |
ClassDef(_vertex_, 2)
|
| 332 |
|
| 333 |
};
|
| 334 |
|
| 335 |
|
| 336 |
|
| 337 |
class _l1_obj_ : public TObject {
|
| 338 |
|
| 339 |
public:
|
| 340 |
|
| 341 |
Int_t triggerInfo; // 1/0xxxxyyyy: xxxx trigger bits belonging; yyyy data type
|
| 342 |
|
| 343 |
Float_t et;
|
| 344 |
Float_t charge;
|
| 345 |
Float_t eta;
|
| 346 |
Float_t phi;
|
| 347 |
|
| 348 |
|
| 349 |
_l1_obj_();
|
| 350 |
_l1_obj_(const _l1_obj_ & orig) ;
|
| 351 |
virtual ~_l1_obj_();
|
| 352 |
|
| 353 |
|
| 354 |
ClassDef(_l1_obj_, 2)
|
| 355 |
};
|
| 356 |
|
| 357 |
|
| 358 |
|
| 359 |
|
| 360 |
|
| 361 |
class _photon_ : public TObject {
|
| 362 |
|
| 363 |
public:
|
| 364 |
|
| 365 |
// basic information
|
| 366 |
Float_t et, eta, phi;
|
| 367 |
Int_t hasPixelSeed, hasConversionTracks;
|
| 368 |
|
| 369 |
|
| 370 |
// photon type
|
| 371 |
// bool isEB() const{return fiducialFlagBlock_.isEB;}
|
| 372 |
// bool isEE() const{return fiducialFlagBlock_.isEE;}
|
| 373 |
// bool isEBGap() const { return (isEBEtaGap() || isEBPhiGap()); }
|
| 374 |
// bool isEBEtaGap() const{return fiducialFlagBlock_.isEBEtaGap;}
|
| 375 |
// bool isEBPhiGap() const{return fiducialFlagBlock_.isEBPhiGap;}
|
| 376 |
// bool isEEGap() const { return (isEERingGap() || isEEDeeGap()); }
|
| 377 |
// bool isEERingGap() const{return fiducialFlagBlock_.isEERingGap;}
|
| 378 |
// bool isEEDeeGap() const{return fiducialFlagBlock_.isEEDeeGap;}
|
| 379 |
// bool isEBEEGap() const{return fiducialFlagBlock_.isEBEEGap;}
|
| 380 |
Int_t fiducialFlags;
|
| 381 |
|
| 382 |
// shower shape
|
| 383 |
Float_t sigmaEtaEta, sigmaIetaIeta, e1x5, e2x5, e3x3, e5x5;
|
| 384 |
Float_t maxEnergyXtal;
|
| 385 |
Float_t hadronicDepth1OverEm, hadronicDepth2OverEm, hadronicOverEm;
|
| 386 |
Float_t r1x5, r2x5, r9;
|
| 387 |
|
| 388 |
|
| 389 |
// Isolation variables
|
| 390 |
Float_t ecalRecHitSumEtConeDR04, hcalTowerSumEtConeDR04;
|
| 391 |
Float_t hcalDepth1TowerSumEtConeDR04, hcalDepth2TowerSumEtConeDR04;
|
| 392 |
Float_t trkSumPtSolidConeDR04, trkSumPtHollowConeDR04;
|
| 393 |
Float_t nTrkSolidConeDR04, nTrkHollowConeDR04;
|
| 394 |
|
| 395 |
Float_t ecalRecHitSumEtConeDR03, hcalTowerSumEtConeDR03;
|
| 396 |
Float_t hcalDepth1TowerSumEtConeDR03, hcalDepth2TowerSumEtConeDR03;
|
| 397 |
Float_t trkSumPtSolidConeDR03, trkSumPtHollowConeDR03;
|
| 398 |
Float_t nTrkSolidConeDR03, nTrkHollowConeDR03;
|
| 399 |
|
| 400 |
|
| 401 |
// superclustr information
|
| 402 |
Float_t scRawEnergy, scPreshowerEnergy, scPhiWidth, scEtaWidth;
|
| 403 |
Int_t scClustersSize;
|
| 404 |
|
| 405 |
Float_t cluster2ndMoments_sMaj, cluster2ndMoments_sMin;
|
| 406 |
Float_t cluster2ndMoments_alpha;
|
| 407 |
Float_t energy, centroidX, centroidY, centroidZ;
|
| 408 |
Int_t size;
|
| 409 |
|
| 410 |
|
| 411 |
_photon_();
|
| 412 |
_photon_(const _photon_ & orig);
|
| 413 |
virtual ~_photon_();
|
| 414 |
|
| 415 |
|
| 416 |
ClassDef(_photon_, 2)
|
| 417 |
};
|
| 418 |
|
| 419 |
|
| 420 |
class _electron_ : public _track_ {
|
| 421 |
|
| 422 |
|
| 423 |
public:
|
| 424 |
|
| 425 |
// basic information
|
| 426 |
Int_t classification;
|
| 427 |
Int_t scPixCharge,isGsfCtfScPixChargeConsistent, isGsfScPixChargeConsistent, isGsfCtfChargeConsistent;
|
| 428 |
Int_t ecalDrivenSeed, trackerDrivenSeed;
|
| 429 |
|
| 430 |
|
| 431 |
// for spike rejection, conversion rejection, etc.
|
| 432 |
Float_t swissCross, dist, dcot;
|
| 433 |
Int_t isElFromConversion;
|
| 434 |
|
| 435 |
|
| 436 |
// superclustr information
|
| 437 |
Float_t scEt, scEta, scPhi;
|
| 438 |
Float_t energy, centroidX, centroidY, centroidZ;
|
| 439 |
Int_t size;
|
| 440 |
Float_t scRawEnergy, scPreshowerEnergy, scPhiWidth, scEtaWidth;
|
| 441 |
Int_t scClustersSize;
|
| 442 |
|
| 443 |
// additional track information
|
| 444 |
Int_t chargeMode;
|
| 445 |
Float_t qoverpMode, lambdaMode, ptMode, phiMode, etaMode;
|
| 446 |
Float_t qoverpModeError, lambdaModeError, ptModeError, phiModeError, etaModeError;
|
| 447 |
|
| 448 |
// track-cluster matching
|
| 449 |
Float_t eSuperClusterOverP ;
|
| 450 |
Float_t eSeedClusterOverP ;
|
| 451 |
Float_t eSeedClusterOverPout ;
|
| 452 |
Float_t eEleClusterOverPout ;
|
| 453 |
Float_t deltaEtaSuperClusterTrackAtVtx ;
|
| 454 |
Float_t deltaEtaSeedClusterTrackAtCalo ;
|
| 455 |
Float_t deltaEtaEleClusterTrackAtCalo ;
|
| 456 |
Float_t deltaPhiEleClusterTrackAtCalo ;
|
| 457 |
Float_t deltaPhiSuperClusterTrackAtVtx ;
|
| 458 |
Float_t deltaPhiSeedClusterTrackAtCalo ;
|
| 459 |
|
| 460 |
Int_t fiducialFlags;
|
| 461 |
|
| 462 |
|
| 463 |
// isolation variables
|
| 464 |
Float_t dr03TkSumPt, dr03EcalRecHitSumEt, dr03HcalDepth1TowerSumEt, dr03HcalDepth2TowerSumEt, dr03HcalTowerSumEt;
|
| 465 |
Float_t dr04TkSumPt, dr04EcalRecHitSumEt, dr04HcalDepth1TowerSumEt, dr04HcalDepth2TowerSumEt, dr04HcalTowerSumEt;
|
| 466 |
|
| 467 |
|
| 468 |
|
| 469 |
// shower shape variables
|
| 470 |
Float_t sigmaEtaEta, sigmaIetaIeta, e1x5, e2x5Max, e5x5, hcalDepth1OverEcal, hcalDepth2OverEcal, hcalOverEcal;
|
| 471 |
|
| 472 |
|
| 473 |
// preselection info
|
| 474 |
Int_t ecalDriven, passingCutBasedPreselection, passingMvaPreselection;
|
| 475 |
Float_t mva;
|
| 476 |
|
| 477 |
|
| 478 |
// brem
|
| 479 |
Float_t fbrem;
|
| 480 |
Int_t numberOfBrems;
|
| 481 |
|
| 482 |
|
| 483 |
//
|
| 484 |
Int_t isMomentumCorrected;
|
| 485 |
Float_t ecalEnergy, ecalEnergyError, trackMomentumError, electronMomentumError;
|
| 486 |
|
| 487 |
|
| 488 |
_electron_();
|
| 489 |
_electron_(const _electron_ & orig);
|
| 490 |
virtual ~_electron_();
|
| 491 |
|
| 492 |
ClassDef(_electron_, 2)
|
| 493 |
};
|
| 494 |
|
| 495 |
|
| 496 |
class _beam_spot_ : public TObject{
|
| 497 |
|
| 498 |
public:
|
| 499 |
|
| 500 |
|
| 501 |
Float_t x0, y0, z0;
|
| 502 |
Float_t x0Error, y0Error, z0Error;
|
| 503 |
Float_t sigmaZ, sigmaZError;
|
| 504 |
Float_t BeamWidthXError, BeamWidthYError;
|
| 505 |
|
| 506 |
|
| 507 |
_beam_spot_();
|
| 508 |
_beam_spot_(const _beam_spot_ & orig);
|
| 509 |
virtual ~_beam_spot_();
|
| 510 |
|
| 511 |
|
| 512 |
ClassDef(_beam_spot_, 2)
|
| 513 |
};
|
| 514 |
|
| 515 |
|
| 516 |
|
| 517 |
|
| 518 |
class _muon_ : public _track_ {
|
| 519 |
|
| 520 |
public:
|
| 521 |
|
| 522 |
Int_t muonType;
|
| 523 |
|
| 524 |
// global track parameters
|
| 525 |
// TeV Muon Refit
|
| 526 |
Int_t refitCharge;
|
| 527 |
Float_t refitPt, refitEta, refitPhi;
|
| 528 |
|
| 529 |
Float_t globalDxy0, globalDz0, globalDsz0;
|
| 530 |
Float_t globalDxy0Error, globalDz0Error, globalDsz0Error;
|
| 531 |
Float_t globalDxy, globalDz, globalDsz;
|
| 532 |
Float_t globalDxyVtx, globalDzVtx, globalDszVtx;
|
| 533 |
|
| 534 |
Int_t globalRecHitsSize, globalNumberOfValidHits, globalCharge;
|
| 535 |
Float_t globalPt, globalEta, globalPhi;
|
| 536 |
Float_t globalPtError, globalEtaError, globalPhiError;
|
| 537 |
Float_t globalNormalizedChi2;
|
| 538 |
|
| 539 |
|
| 540 |
// inner track with respecting to closest primary vertex.
|
| 541 |
Float_t dxyVtx, dzVtx, dszVtx;
|
| 542 |
|
| 543 |
|
| 544 |
// outer track information
|
| 545 |
Float_t outerPt, outerEta, outerPhi;
|
| 546 |
Float_t outerPtError, outerEtaError, outerPhiError;
|
| 547 |
Int_t outerRecHitsSize, outerNumberOfValidHits, outerCharge, outerInnerOk;
|
| 548 |
|
| 549 |
|
| 550 |
// Global variables
|
| 551 |
Int_t numberOfChambers, stationGapMaskPull, numberOfMatches;
|
| 552 |
Int_t stationMask;
|
| 553 |
|
| 554 |
// timing information
|
| 555 |
Int_t timenDof, isTimeValid;
|
| 556 |
Float_t timeAtIPInOut, timeAtIPInOutErr;
|
| 557 |
Float_t timeAtIPOutIn, timeAtIPOutInErr;
|
| 558 |
|
| 559 |
// compatibility
|
| 560 |
Int_t isCaloCompatibilityValid;
|
| 561 |
Float_t caloCompatibility;
|
| 562 |
|
| 563 |
// isolation
|
| 564 |
Int_t isIsolationValid;
|
| 565 |
Float_t isolationR03hadEt, isolationR03emEt, isolationR03sumPt, isolationR03nTracks, isolationR03nJets, isolationR03hoEt;
|
| 566 |
Float_t isolationR05hadEt, isolationR05emEt, isolationR05sumPt, isolationR05nTracks, isolationR05nJets, isolationR05hoEt;
|
| 567 |
|
| 568 |
Float_t isolationR03emVetoEt, isolationR03hadVetoEt, isolationR03hoVetoEt;
|
| 569 |
Float_t isolationR05emVetoEt, isolationR05hadVetoEt, isolationR05hoVetoEt;
|
| 570 |
|
| 571 |
|
| 572 |
// muon energy
|
| 573 |
Int_t isEnergyValid;
|
| 574 |
Float_t calEnergy, calEnergyem, calEnergyhad, calEnergyho;
|
| 575 |
Float_t calEnergyecal_time, calEnergyhcal_time;
|
| 576 |
Float_t calEnergyecal_timeError, calEnergyhcal_timeError;
|
| 577 |
|
| 578 |
_muon_();
|
| 579 |
_muon_(const _muon_ & orig);
|
| 580 |
virtual ~_muon_();
|
| 581 |
|
| 582 |
ClassDef(_muon_, 2)
|
| 583 |
};
|
| 584 |
|
| 585 |
class _gen_jet_ : public TObject {
|
| 586 |
|
| 587 |
public:
|
| 588 |
|
| 589 |
Float_t pt, eta, phi, mass;
|
| 590 |
Int_t mc_flavor, nConstituent ;
|
| 591 |
|
| 592 |
_gen_jet_();
|
| 593 |
_gen_jet_(const _gen_jet_ & orig);
|
| 594 |
virtual ~_gen_jet_();
|
| 595 |
|
| 596 |
|
| 597 |
ClassDef(_gen_jet_, 2)
|
| 598 |
};
|
| 599 |
|
| 600 |
|
| 601 |
class _jet_ : public TObject {
|
| 602 |
|
| 603 |
public:
|
| 604 |
|
| 605 |
Float_t pt, eta, phi, mass;
|
| 606 |
Float_t physicsEta, physicsPt, physicsPhi;
|
| 607 |
|
| 608 |
Int_t nConstituent;
|
| 609 |
Float_t L2L3pt, L2L3scale, L4scale, L5scale, L6scale, L7scale, L8scale;
|
| 610 |
Float_t pileup;
|
| 611 |
|
| 612 |
// calo jets
|
| 613 |
Float_t n60, n90;
|
| 614 |
Float_t emEnergyInEE, emEnergyInHF, emEnergyInEB;
|
| 615 |
Float_t hadEnergyInHB, hadEnergyInHO, hadEnergyInHF, hadEnergyInHE;
|
| 616 |
Float_t emEnergyFraction, energyFractionHadronic;
|
| 617 |
Float_t maxEInEmTowers, maxEInHadTowers;
|
| 618 |
|
| 619 |
|
| 620 |
// common between JPT and PF jet
|
| 621 |
// for JPT jet the electronMultiplicity is (elecMultiplicity)
|
| 622 |
Int_t muonMultiplicity, chargedMultiplicity, electronMultiplicity;
|
| 623 |
Float_t chargedHadronEnergy, chargedHadronEnergyFraction;
|
| 624 |
Float_t neutralHadronEnergy, neutralHadronEnergyFraction;
|
| 625 |
Float_t chargedEmEnergy, chargedEmEnergyFraction;
|
| 626 |
Float_t neutralEmEnergy, neutralEmEnergyFraction;
|
| 627 |
|
| 628 |
|
| 629 |
// JPT jets
|
| 630 |
Float_t zspCor;
|
| 631 |
|
| 632 |
|
| 633 |
// PF jets
|
| 634 |
Float_t photonEnergy, photonEnergyFraction;
|
| 635 |
Float_t electronEnergy, electronEnergyFraction;
|
| 636 |
Float_t muonEnergy, muonEnergyFraction;
|
| 637 |
Float_t HFHadronEnergy, HFHadronEnergyFraction;
|
| 638 |
Float_t HFEMEnergy, HFEMEnergyFraction;
|
| 639 |
|
| 640 |
Int_t chargedHadronMultiplicity, neutralHadronMultiplicity;
|
| 641 |
Int_t photonMultiplicity, HFHadronMultiplicity, HFEMMultiplicity;
|
| 642 |
Float_t chargedMuEnergy, chargedMuEnergyFraction;
|
| 643 |
Int_t neutralMultiplicity;
|
| 644 |
|
| 645 |
|
| 646 |
// MC information
|
| 647 |
Float_t mc_flavor, mc_pt, mc_eta, mc_phi;
|
| 648 |
|
| 649 |
// btagging variables
|
| 650 |
Float_t tag[EDM_MAX_LENGTH];
|
| 651 |
Float_t flavor[EDM_MAX_LENGTH];
|
| 652 |
|
| 653 |
|
| 654 |
_jet_();
|
| 655 |
_jet_(const _jet_ & orig);
|
| 656 |
virtual ~_jet_();
|
| 657 |
|
| 658 |
ClassDef(_jet_, 2)
|
| 659 |
};
|
| 660 |
|
| 661 |
|
| 662 |
|
| 663 |
class _di_jet_ : public TObject {
|
| 664 |
|
| 665 |
public:
|
| 666 |
|
| 667 |
Int_t jetType, charge, daughtA, daughtB;
|
| 668 |
Float_t pt, eta, phi, rapidity, mass;
|
| 669 |
|
| 670 |
|
| 671 |
// results from vertex constrainted fit
|
| 672 |
Bool_t isValid;
|
| 673 |
Float_t totalChiSquared, chiSquaredProbability;
|
| 674 |
Float_t degreesOfFreedom;
|
| 675 |
Float_t vx, vy, vz;
|
| 676 |
Float_t vxError, vyError, vzError;
|
| 677 |
|
| 678 |
_di_jet_();
|
| 679 |
_di_jet_(const _di_jet_ & orig);
|
| 680 |
virtual ~_di_jet_();
|
| 681 |
|
| 682 |
|
| 683 |
ClassDef(_di_jet_, 2)
|
| 684 |
};
|
| 685 |
|
| 686 |
|
| 687 |
/**************************************************************************
|
| 688 |
*
|
| 689 |
* composition of candidates
|
| 690 |
*
|
| 691 |
**************************************************************************/
|
| 692 |
class _W_ : public TObject{
|
| 693 |
|
| 694 |
public:
|
| 695 |
|
| 696 |
Int_t leptonIndex, leptonType;
|
| 697 |
|
| 698 |
// with assumption of muons from W decays.
|
| 699 |
// calculate the Rapidity distribution.
|
| 700 |
Float_t recoWy1;
|
| 701 |
Float_t recoWy2;
|
| 702 |
Float_t delta;
|
| 703 |
|
| 704 |
_W_();
|
| 705 |
_W_(const _W_ & orig);
|
| 706 |
virtual ~_W_();
|
| 707 |
|
| 708 |
ClassDef(_W_, 2)
|
| 709 |
};
|
| 710 |
|
| 711 |
|
| 712 |
|
| 713 |
class _di_lepton_ : public TObject{
|
| 714 |
|
| 715 |
public:
|
| 716 |
|
| 717 |
|
| 718 |
Float_t x1, x2;
|
| 719 |
Float_t xfx1, xfx2;
|
| 720 |
Float_t mistag;
|
| 721 |
Float_t qqbar, qbarq; //
|
| 722 |
|
| 723 |
|
| 724 |
Int_t charge;
|
| 725 |
Int_t daughtA, daughtB;
|
| 726 |
Int_t daughtAType, daughtBType;
|
| 727 |
|
| 728 |
// the composite particle
|
| 729 |
// Float_t px, py, pz, p0;
|
| 730 |
Float_t pt, eta, phi;
|
| 731 |
Float_t rapidity;
|
| 732 |
Float_t mass;
|
| 733 |
|
| 734 |
|
| 735 |
|
| 736 |
// results from vertex constrainted fit
|
| 737 |
Bool_t isValid;
|
| 738 |
Float_t totalChiSquared, chiSquaredProbability;
|
| 739 |
Float_t degreesOfFreedom;
|
| 740 |
Float_t fittedMass;
|
| 741 |
Float_t vx, vy, vz;
|
| 742 |
Float_t vxError, vyError, vzError;
|
| 743 |
|
| 744 |
Float_t e1, e2, cosPhiFit; // after refit
|
| 745 |
|
| 746 |
// angles in rest frame of di-lepton pair following Collins-Soper convention
|
| 747 |
Float_t cosPhi; // angle between the two muons.
|
| 748 |
Float_t cosTheta;
|
| 749 |
Float_t cosThetaCS;
|
| 750 |
Float_t sin2Theta;
|
| 751 |
Float_t tanPhi;
|
| 752 |
|
| 753 |
|
| 754 |
|
| 755 |
_di_lepton_();
|
| 756 |
_di_lepton_(const _di_lepton_ & orig);
|
| 757 |
virtual ~_di_lepton_();
|
| 758 |
|
| 759 |
ClassDef(_di_lepton_, 2)
|
| 760 |
};
|
| 761 |
|
| 762 |
|
| 763 |
class _tri_lepton_ : public TObject{
|
| 764 |
|
| 765 |
public:
|
| 766 |
|
| 767 |
|
| 768 |
Int_t dileptonIndex;
|
| 769 |
Int_t leptonIndex;
|
| 770 |
Int_t leptonType;
|
| 771 |
|
| 772 |
Int_t charge;
|
| 773 |
Float_t m12, eta12, pt12, phi12, mt3, rapidity12;
|
| 774 |
Float_t m23, eta23, pt23, phi23, mt1, rapidity23;
|
| 775 |
|
| 776 |
Float_t mass, eta, rapidity, pt, phi, theta12, theta23, mt;
|
| 777 |
|
| 778 |
|
| 779 |
_tri_lepton_();
|
| 780 |
_tri_lepton_(const _tri_lepton_ & orig);
|
| 781 |
virtual ~_tri_lepton_();
|
| 782 |
|
| 783 |
ClassDef(_tri_lepton_, 2)
|
| 784 |
};
|
| 785 |
|
| 786 |
|
| 787 |
class _quar_lepton_ : public TObject{
|
| 788 |
|
| 789 |
public:
|
| 790 |
|
| 791 |
Int_t charge;
|
| 792 |
Int_t dileptonIndex;
|
| 793 |
Int_t leptonType, leptonIndex1, leptonIndex2;
|
| 794 |
|
| 795 |
|
| 796 |
Float_t m12, pt12, eta12, rapidity12, phi12;
|
| 797 |
Float_t m34, pt34, eta34, rapidity34, phi34;
|
| 798 |
|
| 799 |
Float_t thetaStar;
|
| 800 |
|
| 801 |
Float_t mass, pt, eta, phi, rapidity;
|
| 802 |
|
| 803 |
_quar_lepton_();
|
| 804 |
_quar_lepton_(const _quar_lepton_ & orig);
|
| 805 |
virtual ~_quar_lepton_();
|
| 806 |
|
| 807 |
ClassDef(_quar_lepton_, 2)
|
| 808 |
};
|
| 809 |
|
| 810 |
|
| 811 |
class _lepton_photon_ : public TObject{
|
| 812 |
|
| 813 |
public:
|
| 814 |
|
| 815 |
Int_t charge;
|
| 816 |
Int_t leptonIndex, photonIndex;
|
| 817 |
Int_t leptonType;
|
| 818 |
|
| 819 |
Float_t pt, eta, phi;
|
| 820 |
Float_t rapidity;
|
| 821 |
Float_t mass;
|
| 822 |
|
| 823 |
Float_t cosPhi;
|
| 824 |
|
| 825 |
|
| 826 |
_lepton_photon_();
|
| 827 |
_lepton_photon_(const _lepton_photon_ & orig);
|
| 828 |
virtual ~_lepton_photon_();
|
| 829 |
|
| 830 |
ClassDef(_lepton_photon_, 2)
|
| 831 |
};
|
| 832 |
|
| 833 |
|
| 834 |
|
| 835 |
class _dilepton_photon_ : public TObject{
|
| 836 |
|
| 837 |
public:
|
| 838 |
|
| 839 |
Int_t charge;
|
| 840 |
Int_t dileptonIndex, photonIndex;
|
| 841 |
|
| 842 |
Float_t pt, eta, phi;
|
| 843 |
Float_t rapidity;
|
| 844 |
|
| 845 |
// lepton pairs are ordered as:
|
| 846 |
// mumu
|
| 847 |
// mue
|
| 848 |
// ee
|
| 849 |
// the order sequence within a group is charge first then pt.
|
| 850 |
Float_t mll, m1g, m2g, mass;
|
| 851 |
|
| 852 |
Float_t cosPhi;
|
| 853 |
|
| 854 |
|
| 855 |
_dilepton_photon_();
|
| 856 |
_dilepton_photon_(const _dilepton_photon_ & orig);
|
| 857 |
virtual ~_dilepton_photon_();
|
| 858 |
|
| 859 |
ClassDef(_dilepton_photon_, 2)
|
| 860 |
};
|
| 861 |
|
| 862 |
|
| 863 |
|
| 864 |
/**************************************************************************
|
| 865 |
*
|
| 866 |
* event definition
|
| 867 |
*
|
| 868 |
**************************************************************************/
|
| 869 |
class _event_ : public TObject{
|
| 870 |
|
| 871 |
public:
|
| 872 |
|
| 873 |
|
| 874 |
// Float_t x1, x2;
|
| 875 |
Long_t eventNum, runNum, lumiBlock;
|
| 876 |
Int_t bunchCrossing, orbitNum;
|
| 877 |
Long_t timeLow, timeHigh;
|
| 878 |
|
| 879 |
Float_t eventWeight, BField;
|
| 880 |
|
| 881 |
|
| 882 |
Int_t simTrackNum;
|
| 883 |
|
| 884 |
Int_t vertexNum;
|
| 885 |
Int_t photonNum;
|
| 886 |
Int_t electronNum;
|
| 887 |
Int_t trackNum;
|
| 888 |
Int_t jetNum, genJetNum, akGenJetNum;
|
| 889 |
Int_t caloJetNum;
|
| 890 |
Int_t jptJetNum;
|
| 891 |
Int_t pfJetNum;
|
| 892 |
Int_t muonNum;
|
| 893 |
|
| 894 |
Int_t WNum;
|
| 895 |
Int_t quarleptonNum, trileptonNum, dileptonNum;
|
| 896 |
Int_t dijetNum;
|
| 897 |
Int_t leptonTrkPairNum,leptonPhotonNum,dileptonPhotonNum;
|
| 898 |
|
| 899 |
// trigger information
|
| 900 |
Int_t l1ObjNum;
|
| 901 |
Int_t hltObjNum;
|
| 902 |
|
| 903 |
|
| 904 |
_trg_bits_ trgBits;
|
| 905 |
|
| 906 |
// high level trigger information.
|
| 907 |
Int_t hltElectronNum;
|
| 908 |
TClonesArray *hltElectrons;
|
| 909 |
Int_t hltElectronLNum;
|
| 910 |
TClonesArray *hltElectronLs;
|
| 911 |
Int_t hltMuonNum;
|
| 912 |
TClonesArray *hltMuons;
|
| 913 |
Int_t hltMuonLNum;
|
| 914 |
TClonesArray *hltMuonLs;
|
| 915 |
|
| 916 |
TClonesArray *vertices;
|
| 917 |
TClonesArray *photons;
|
| 918 |
TClonesArray *electrons;
|
| 919 |
TClonesArray *l1Objs;
|
| 920 |
TClonesArray *tracks;
|
| 921 |
TClonesArray *jets, *genJets, *akGenJets;
|
| 922 |
TClonesArray *caloJets;
|
| 923 |
TClonesArray *jptJets;
|
| 924 |
TClonesArray *pfJets;
|
| 925 |
TClonesArray *simTracks;
|
| 926 |
TClonesArray *muons;
|
| 927 |
|
| 928 |
|
| 929 |
TClonesArray *Ws;
|
| 930 |
TClonesArray *dileptons;
|
| 931 |
TClonesArray *dijets;
|
| 932 |
TClonesArray *trileptons;
|
| 933 |
TClonesArray *quarleptons;
|
| 934 |
TClonesArray *leptonphotons;
|
| 935 |
TClonesArray *dileptonphotons;
|
| 936 |
TClonesArray *leptonTrkPairs;
|
| 937 |
|
| 938 |
|
| 939 |
_beam_spot_ beamSpot;
|
| 940 |
_mc_process_ mc;
|
| 941 |
_genwz_ genwz;
|
| 942 |
_run_info_ runInfo;
|
| 943 |
_hlt_info_ hltInfo;
|
| 944 |
_mets_ mets;
|
| 945 |
_dileadingjets_ dileadingjets;
|
| 946 |
|
| 947 |
|
| 948 |
|
| 949 |
// member functions
|
| 950 |
_event_();
|
| 951 |
virtual ~_event_();
|
| 952 |
|
| 953 |
|
| 954 |
void setEventNum(Long_t num) {eventNum = num;}
|
| 955 |
void setRunNum(Long_t num) {runNum = num;}
|
| 956 |
void setLumiBlock(Long_t num) {lumiBlock = num;}
|
| 957 |
|
| 958 |
void setBunchCrossing(Int_t num) {bunchCrossing = num;}
|
| 959 |
void setOrbitNum(Int_t num) {orbitNum = num;}
|
| 960 |
void setTimeLow(Long_t num) {timeLow = num;}
|
| 961 |
void setTimeHigh(Long_t num) {timeHigh = num;}
|
| 962 |
|
| 963 |
void setEventWeight(Float_t f) {eventWeight = f; }
|
| 964 |
void setBField(Float_t f) {BField = f; }
|
| 965 |
|
| 966 |
TClonesArray *getHLTElectrons() {return hltElectrons;}
|
| 967 |
TClonesArray *getHLTElectronsL() {return hltElectronLs;}
|
| 968 |
TClonesArray *getHLTMuons() {return hltMuons;}
|
| 969 |
TClonesArray *getHLTMuonsL() {return hltMuonLs;}
|
| 970 |
|
| 971 |
TClonesArray *getVertices() {return vertices;}
|
| 972 |
TClonesArray *getPhotons() {return photons;}
|
| 973 |
TClonesArray *getElectrons() {return electrons;}
|
| 974 |
TClonesArray *getL1Objs() {return l1Objs;}
|
| 975 |
TClonesArray *getTracks() {return tracks;}
|
| 976 |
TClonesArray *getJets() {return jets;}
|
| 977 |
TClonesArray *getGenJets() {return genJets;}
|
| 978 |
TClonesArray *getAKGenJets() {return akGenJets;}
|
| 979 |
|
| 980 |
TClonesArray *getCaloJets() {return caloJets;}
|
| 981 |
TClonesArray *getJPTJets() {return jptJets;}
|
| 982 |
TClonesArray *getPFJets() {return pfJets;}
|
| 983 |
|
| 984 |
|
| 985 |
TClonesArray *getMuons() {return muons;}
|
| 986 |
TClonesArray *getSimTracks() {return simTracks;}
|
| 987 |
|
| 988 |
TClonesArray *getWs() {return Ws;}
|
| 989 |
TClonesArray *getDileptons() {return dileptons;}
|
| 990 |
TClonesArray *getDijets() {return dijets;}
|
| 991 |
TClonesArray *getTrileptons() {return trileptons;}
|
| 992 |
TClonesArray *getQuarleptons() {return quarleptons;}
|
| 993 |
TClonesArray *getLeptonPhotons() {return leptonphotons;}
|
| 994 |
TClonesArray *getDileptonPhotons() {return dileptonphotons;}
|
| 995 |
TClonesArray *getLeptonTrkPairs() {return leptonTrkPairs;}
|
| 996 |
|
| 997 |
_trg_bits_ *getTrgBits() {return &trgBits;}
|
| 998 |
_mc_process_ *getMCInfo() {return &mc;}
|
| 999 |
_beam_spot_ *getBeamSpot() {return &beamSpot;}
|
| 1000 |
_genwz_ *getGenWZ() {return &genwz;}
|
| 1001 |
_run_info_ *getRunInfo() {return &runInfo;}
|
| 1002 |
_hlt_info_ *getHLTInfo() {return &hltInfo;}
|
| 1003 |
_mets_ *getMETs() {return &mets;}
|
| 1004 |
_dileadingjets_ *getDiLeadingJets() {return &dileadingjets;}
|
| 1005 |
|
| 1006 |
_vec4_ *addHLTMuon();
|
| 1007 |
_vec4_ *addHLTMuonL();
|
| 1008 |
_vec4_ *addHLTElectron();
|
| 1009 |
_vec4_ *addHLTElectronL();
|
| 1010 |
|
| 1011 |
_vertex_ *addVertex();
|
| 1012 |
_photon_ *addPhoton();
|
| 1013 |
_electron_ *addElectron();
|
| 1014 |
_l1_obj_ *addL1Obj();
|
| 1015 |
_track_ *addSimTrack();
|
| 1016 |
_track_ *addTrack();
|
| 1017 |
|
| 1018 |
_gen_jet_ *addGenJet();
|
| 1019 |
_gen_jet_ *addAKGenJet();
|
| 1020 |
_jet_ *addJet();
|
| 1021 |
|
| 1022 |
_jet_ *addCaloJet();
|
| 1023 |
_jet_ *addJPTJet();
|
| 1024 |
_jet_ *addPFJet();
|
| 1025 |
|
| 1026 |
_muon_ *addMuon();
|
| 1027 |
|
| 1028 |
_W_ *addW();
|
| 1029 |
_di_lepton_ *addDilepton();
|
| 1030 |
_di_jet_ *addDijet();
|
| 1031 |
_tri_lepton_ *addTrilepton();
|
| 1032 |
|
| 1033 |
|
| 1034 |
_quar_lepton_ *addQuarlepton();
|
| 1035 |
_lepton_photon_ *addLeptonPhoton();
|
| 1036 |
_dilepton_photon_ *addDileptonPhoton();
|
| 1037 |
_di_lepton_ *addLeptonTrkPair();
|
| 1038 |
|
| 1039 |
|
| 1040 |
void reset();
|
| 1041 |
void Clear();
|
| 1042 |
|
| 1043 |
ClassDef(_event_, 1)
|
| 1044 |
};
|
| 1045 |
|
| 1046 |
bool isEB(Int_t flag);
|
| 1047 |
bool isEE(Int_t flag);
|
| 1048 |
bool isGap(Int_t flag);
|
| 1049 |
bool isEBEEGap(Int_t flag);
|
| 1050 |
bool isEBGap(Int_t flag);
|
| 1051 |
bool isEBEtaGap(Int_t flag);
|
| 1052 |
bool isEBPhiGap(Int_t flag);
|
| 1053 |
bool isEEGap(Int_t flag);
|
| 1054 |
bool isEEDeeGap(Int_t flag);
|
| 1055 |
bool isEERingGap(Int_t flag);
|
| 1056 |
|
| 1057 |
_vec4_ *addHLTMuonL(_event_ *aEvent);
|
| 1058 |
_vec4_ *addHLTMuon(_event_ *aEvent);
|
| 1059 |
_vec4_ *addHLTElectronL(_event_ *aEvent);
|
| 1060 |
_vec4_ *addHLTElectron(_event_ *aEvent);
|
| 1061 |
|
| 1062 |
|
| 1063 |
#endif
|
