HLT/MUON/AliHLTMUONDecision.h

   1 #ifndef ALIHLTMUONDECISION_H
   2 #define ALIHLTMUONDECISION_H
   3 /* This file is property of and copyright by the ALICE HLT Project        *
   4  * ALICE Experiment at CERN, All rights reserved.                         *
   5  * See cxx source for full Copyright notice                               */
   6
   7 /* $Id: $ */
   8
   9 ///
  10 /// @file   AliHLTMUONDecision.h
  11 /// @author Artur Szostak <artursz@iafrica.com>
  12 /// @date   12 May 2008
  13 /// @brief  Declaration of a dHLT decision object in ROOT object format.
  14 ///
  15
  16 #include "TObject.h"
  17 #include "TClonesArray.h"
  18
  19 class AliHLTMUONMansoTrack;
  20
  21 /**
  22  * AliHLTMUONDecision stores converted dHLT raw trigger decision data as a ROOT object.
  23  * Both AliHLTMUONSinglesDecisionBlockStruct and AliHLTMUONPairsDecisionBlockStruct
  24  * data blocks are converted into this class by the AliHLTMUONRootifierComponent.
  25  * This class is mainly for testing or as a helper object for dHLT specific analysis,
  26  * since it is sometimes easier to store and handle ROOT objects.
  27  */
  28 class AliHLTMUONDecision : public TObject
  29 {
  30         /**
  31          * Stream operator for usage with std::ostream classes.
  32          * Allows usage such as:
  33          *   AliHLTMUONDecision t; std::cout << t;
  34          */
  35         friend std::ostream& operator << (
  36                         std::ostream& stream,
  37                         const AliHLTMUONDecision& decision
  38                 );
  39
  40 public:
  41
  42         /**
  43          * The AliTrackDecision class stores per track trigger information.
  44          */
  45         class AliTrackDecision : public TObject
  46         {
  47                 /**
  48                  * Stream operator for usage with std::ostream classes.
  49                  */
  50                 friend std::ostream& operator << (std::ostream& stream, const AliTrackDecision& decision);
  51
  52         public:
  53
  54                 /**
  55                  * Constructor for new single track trigger decision object.
  56                  * \param pt  The calculated pT value used for the trigger decision.
  57                  * \param passedLowCut  Flag indicating if the track passed the low pT cut.
  58                  * \param passedHighCut  Flag indicating if the track passed the high pT cut.
  59                  * \param track  Pointer to the associated track object.
  60                  */
  61                 AliTrackDecision(
  62                                 Float_t pt = -1,
  63                                 Bool_t passedLowCut = kFALSE,
  64                                 Bool_t passedHighCut = kFALSE,
  65                                 const AliHLTMUONMansoTrack* track = NULL
  66                         ) :
  67                         TObject(), fTrack(track), fPt(pt),
  68                         fPassedLowCut(passedLowCut), fPassedHighCut(passedHighCut)
  69                 {}
  70
  71                 /**
  72                  * Copy constructor performs shallow copy of object since we
  73                  * do not take ownership of the track object.
  74                  */
  75                 AliTrackDecision(const AliTrackDecision& obj) :
  76                         TObject(obj), fTrack(obj.fTrack), fPt(obj.fPt),
  77                         fPassedLowCut(obj.fPassedLowCut), fPassedHighCut(obj.fPassedHighCut)
  78                 {}
  79
  80                 /**
  81                  * Asignment operators performs shallow copy of object since we
  82                  * do not take ownership of the track object.
  83                  */
  84                 const AliTrackDecision& operator = (const AliTrackDecision& obj)
  85                 {
  86                         TObject::operator = (obj);
  87                         fTrack = obj.fTrack; fPt = obj.fPt;
  88                         fPassedLowCut = obj.fPassedLowCut; fPassedHighCut = obj.fPassedHighCut;
  89                         return *this;
  90                 }
  91
  92                 /**
  93                  * Default destructor.
  94                  */
  95                 virtual ~AliTrackDecision() {}
  96
  97                 /**
  98                  * Returns the track associated with the trigger decision or NULL if none found.
  99                  */
 100                 const AliHLTMUONMansoTrack* Track() const { return fTrack; }
 101
 102                 /**
 103                  * Returns the calculated pT value used for the trigger decision.
 104                  */
 105                 Float_t Pt() const { return fPt; }
 106
 107                 /**
 108                  * Returns kTRUE if the track passed the low pT cut, else kFALSE.
 109                  */
 110                 Bool_t PassedLowPtCut() const { return fPassedLowCut; }
 111
 112                 /**
 113                  * Returns kTRUE if the track passed the high pT cut, else kFALSE.
 114                  */
 115                 Bool_t PassedHighPtCut() const { return fPassedHighCut; }
 116
 117                 /// Print method inherited from TObject.
 118                 virtual void Print(Option_t* option = NULL) const;
 119
 120                 // Methods inherited from TObject
 121                 virtual Bool_t IsSortable() const { return kTRUE; }
 122                 Int_t Compare(const TObject* obj) const;
 123
 124                 // Implement comparison operators.
 125                 bool operator == (const AliTrackDecision& d) const
 126                 {
 127                         return fTrack == d.fTrack and fPt == d.fPt
 128                                 and fPassedLowCut == d.fPassedLowCut
 129                                 and fPassedHighCut == d.fPassedHighCut;
 130                 }
 131
 132                 bool operator != (const AliTrackDecision& d) const
 133                 {
 134                         return not this->operator == (d);
 135                 }
 136
 137         private:
 138
 139                 const AliHLTMUONMansoTrack* fTrack; ///< Track associated with this decision.
 140                 Float_t fPt; ///< Calculated pT value used for decision (GeV/c).
 141                 Bool_t fPassedLowCut; ///< Indicates if the track passed the low pT cut.
 142                 Bool_t fPassedHighCut; ///< Indicates if the track passed the high pT cut.
 143
 144                 ClassDef(AliHLTMUONDecision::AliTrackDecision, 3); // A single track dHLT trigger decision object.
 145         };
 146
 147         /**
 148          * The AliPairDecision class stores trigger information about a track pair.
 149          */
 150         class AliPairDecision : public TObject
 151         {
 152                 /**
 153                  * Stream operator for usage with std::ostream classes.
 154                  */
 155                 friend std::ostream& operator << (std::ostream& stream, const AliPairDecision& decision);
 156
 157         public:
 158
 159                 /**
 160                  * Constructor for new track pair trigger decision object.
 161                  * \param mass   The invariant mass of the track pair.
 162                  * \param passedLowCut  Indicates if the pair passed the low mass cut.
 163                  * \param passedHighCut  Indicates if the pair passed the high mass cut.
 164                  * \param unlike   Indicates if the tracks have opposite sign.
 165                  * \param lowPtCount  The number of tracks in the pair that passed the low pT cut.
 166                  *            Should be in the range [0..2].
 167                  * \param highPtCount  The number of tracks in the pair that passed the high pT cut.
 168                  *            Should be in the range [0..2].
 169                  * \param trackA  Pointer to the first associated track object.
 170                  * \param trackB  Pointer to the second associated track object.
 171                  */
 172                 AliPairDecision(
 173                                 Float_t mass = -1, Bool_t passedLowCut = kFALSE,
 174                                 Bool_t passedHighCut = kFALSE, Bool_t unlike = kFALSE,
 175                                 UChar_t lowPtCount = 0, UChar_t highPtCount = 0,
 176                                 const AliHLTMUONMansoTrack* trackA = NULL,
 177                                 const AliHLTMUONMansoTrack* trackB = NULL
 178                         ) :
 179                         TObject(), fTrackA(trackA), fTrackB(trackB), fMass(mass),
 180                         fPassedLowCut(passedLowCut), fPassedHighCut(passedHighCut),
 181                         fUnlike(unlike), fLowPtCount(lowPtCount), fHighPtCount(highPtCount)
 182                 {}
 183
 184                 /**
 185                  * Copy constructor performs shallow copy of object since we
 186                  * do not take ownership of the track objects.
 187                  */
 188                 AliPairDecision(const AliPairDecision& obj) :
 189                         TObject(obj), fTrackA(obj.fTrackA), fTrackB(obj.fTrackB), fMass(obj.fMass),
 190                         fPassedLowCut(obj.fPassedLowCut), fPassedHighCut(obj.fPassedHighCut),
 191                         fUnlike(obj.fUnlike), fLowPtCount(obj.fLowPtCount), fHighPtCount(obj.fHighPtCount)
 192                 {}
 193
 194                 /**
 195                  * Asignment operators performs shallow copy of object since we
 196                  * do not take ownership of the track objects.
 197                  */
 198                 const AliPairDecision& operator = (const AliPairDecision& obj)
 199                 {
 200                         TObject::operator = (obj);
 201                         fTrackA = obj.fTrackA; fTrackB = obj.fTrackB; fMass = obj.fMass; fPassedLowCut = obj.fPassedLowCut;
 202                         fPassedHighCut = obj.fPassedHighCut; fUnlike = obj.fUnlike; fLowPtCount = obj.fLowPtCount; fHighPtCount = obj.fHighPtCount;
 203                         return *this;
 204                 }
 205
 206                 /**
 207                  * Default destructor.
 208                  */
 209                 virtual ~AliPairDecision() {}
 210
 211                 /**
 212                  * Returns the first track associated with the track pair trigger decision
 213                  * or NULL if none found.
 214                  */
 215                 const AliHLTMUONMansoTrack* TrackA() const { return fTrackA; }
 216
 217                 /**
 218                  * Returns the second track associated with the track pair trigger decision
 219                  * or NULL if none found.
 220                  */
 221                 const AliHLTMUONMansoTrack* TrackB() const { return fTrackB; }
 222
 223                 /**
 224                  * Returns the calculated invariant mass value used for the trigger decision.
 225                  */
 226                 Float_t Mass() const { return fMass; }
 227
 228                 /**
 229                  * Returns kTRUE if the track pair passed the low invariant mass cut, else kFALSE.
 230                  */
 231                 Bool_t PassedLowMassCut() const { return fPassedLowCut; }
 232
 233                 /**
 234                  * Returns kTRUE if the track pair passed the high invariant mass cut, else kFALSE.
 235                  */
 236                 Bool_t PassedHighMassCut() const { return fPassedHighCut; }
 237
 238                 /**
 239                  * Returns kTRUE if the track pair has unlike sign, else kFALSE.
 240                  */
 241                 Bool_t UnlikeSign() const { return fUnlike; }
 242
 243                 /**
 244                  * Returns kTRUE if the track pair has like sign, else kFALSE.
 245                  */
 246                 Bool_t LikeSign() const { return not fUnlike; }
 247
 248                 /**
 249                  * Returns the number of tracks in the pair that passed the low pT cut.
 250                  * Can be one of 0, 1 or 2.
 251                  */
 252                 UChar_t NumberPassedLowPtCut() const { return fLowPtCount; }
 253
 254                 /**
 255                  * Returns the number of tracks in the pair that passed the high pT cut.
 256                  * Can be one of 0, 1 or 2.
 257                  */
 258                 UChar_t NumberPassedHighPtCut() const { return fHighPtCount; }
 259
 260                 /**
 261                  * Returns kTRUE if both tracks passed the low pT cut, else kFALSE.
 262                  */
 263                 Bool_t BothPassedLowPtCut() const { return NumberPassedLowPtCut() == 2; }
 264
 265                 /**
 266                  * Returns kTRUE if both tracks passed the high pT cut, else kFALSE.
 267                  */
 268                 Bool_t BothPassedHighPtCut() const { return NumberPassedHighPtCut() == 2; }
 269
 270                 /// Print method inherited from TObject.
 271                 virtual void Print(Option_t* option = NULL) const;
 272
 273                 // Methods inherited from TObject
 274                 virtual Bool_t IsSortable() const { return kTRUE; }
 275                 Int_t Compare(const TObject* obj) const;
 276
 277                 // Implement comparison operators.
 278                 bool operator == (const AliPairDecision& d) const
 279                 {
 280                         return fTrackA == d.fTrackA and fTrackB == d.fTrackB and fMass == d.fMass
 281                                 and fPassedLowCut == d.fPassedLowCut and fPassedHighCut == d.fPassedHighCut
 282                                 and fUnlike == d.fUnlike and fLowPtCount == d.fLowPtCount and fHighPtCount == d.fHighPtCount;
 283                 }
 284
 285                 bool operator != (const AliPairDecision& d) const
 286                 {
 287                         return not this->operator == (d);
 288                 }
 289
 290         private:
 291
 292                 const AliHLTMUONMansoTrack* fTrackA; ///< The first track associated with this pair decision.
 293                 const AliHLTMUONMansoTrack* fTrackB; ///< The second track associated with this pair decision.
 294                 Float_t fMass;  ///< The invariant mass used for the trigger decision. (GeV/c^2)
 295                 Bool_t fPassedLowCut; ///< Indicates if the track passed the low mass cut.
 296                 Bool_t fPassedHighCut; ///< Indicates if the track passed the high mass cut.
 297                 Bool_t fUnlike; ///< Indicates if the track pair has unlike sign.
 298                 UChar_t fLowPtCount; ///< The number of tracks in the pair that passed the low pT cut.
 299                 UChar_t fHighPtCount; ///< The number of tracks in the pair that passed the high pT cut.
 300
 301                 ClassDef(AliHLTMUONDecision::AliPairDecision, 3); // A track pair dHLT trigger decision object.
 302         };
 303
 304         /**
 305          * Constructor for creating a dHLT decision object.
 306          * \param nLowPt  Number of tracks above low pT cut.
 307          * \param nHiPt   Number of tracks above high pT cut.
 308          * \param nUnlikeAnyPt  Number of track pairs with unlike sign.
 309          * \param nUnlikeLowPt  Number of unlike sign track pairs with pT > low cut.
 310          * \param nUnlikeHighPt Number of unlike sign track pairs with pT > high cut.
 311          * \param nLikeAnyPt   Number of track pairs with like sign.
 312          * \param nLikeLowPt   Number of like sign track pairs with pT > low cut.
 313          * \param nLikeHighPt  Number of like sign track pairs with pT > high cut.
 314          * \param nMassAny   Number of unlike sign track pairs with invariant mass > low cut.
 315          * \param nMassLow   Number of unlike sign track pairs with invariant mass > low mass cut and pT > low pT cut.
 316          * \param nMassHigh  Number of unlike sign track pairs with invariant mass > high mass cut and pT > high pT cut.
 317          */
 318         AliHLTMUONDecision(
 319                         UInt_t nLowPt = 0, UInt_t nHiPt = 0,
 320                         UInt_t nUnlikeAnyPt = 0, UInt_t nUnlikeLowPt = 0, UInt_t nUnlikeHighPt = 0,
 321                         UInt_t nLikeAnyPt = 0, UInt_t nLikeLowPt = 0, UInt_t nLikeHighPt = 0,
 322                         UInt_t nMassAny = 0, UInt_t nMassLow = 0, UInt_t nMassHigh = 0
 323                 );
 324
 325         /**
 326          * Default destructor.
 327          */
 328         virtual ~AliHLTMUONDecision() {}
 329
 330         /**
 331          * Returns the number of single low pT triggers.
 332          */
 333         UInt_t NumberOfLowPtTriggers() const { return fNlowPt; }
 334
 335         /**
 336          * Returns the number of single high pT triggers.
 337          */
 338         UInt_t NumberOfHighPtTriggers() const { return fNhighPt; }
 339
 340         /**
 341          * Returns the number of unlike sign pt triggers.
 342          */
 343         UInt_t NumberOfUnlikePairs() const { return fNunlikeAnyPt; }
 344
 345         /**
 346          * Returns the number of unlike sign pT triggers, where both tracks have pT > low cut.
 347          */
 348         UInt_t NumberOfUnlikeLowPtPairs() const { return fNunlikeLowPt; }
 349
 350         /**
 351          * Returns the number of unlike sign pT triggers, where both tracks have pT > high cut.
 352          */
 353         UInt_t NumberOfUnlikeHighPtPairs() const { return fNunlikeHighPt; }
 354
 355         /**
 356          * Returns the number of like sign pt triggers.
 357          */
 358         UInt_t NumberOfLikePairs() const { return fNlikeAnyPt; }
 359
 360         /**
 361          * Returns the number of like sign pT triggers, where both tracks have pT > low cut.
 362          */
 363         UInt_t NumberOfLikeLowPtPairs() const { return fNlikeLowPt; }
 364
 365         /**
 366          * Returns the number of like sign pT triggers, where both tracks have pT > high cut.
 367          */
 368         UInt_t NumberOfLikeHighPtPairs() const { return fNlikeHighPt; }
 369
 370         /**
 371          * Returns the number of invariant mass triggers.
 372          */
 373         UInt_t NumberOfMassTriggers() const { return fNmassAny; }
 374
 375         /**
 376          * Returns the number of invariant mass triggers,
 377          * where invariant mass > low cut and both tracks have pT > low cut.
 378          */
 379         UInt_t NumberOfLowMassTriggers() const { return fNmassLow; }
 380
 381         /**
 382          * Returns the number of invariant mass triggers,
 383          * where invariant mass > high cut and both tracks have pT > high cut.
 384          */
 385         UInt_t NumberOfHighMassTriggers() const { return fNmassHigh; }
 386
 387         /**
 388          * Returns the total number of single tracks that formed part of this trigger decision.
 389          */
 390         Int_t NumberOfTracks() const { return fTrackDecisions.GetEntriesFast(); }
 391
 392         /**
 393          * Returns the i'th trigger decision for a single track.
 394          * \param i  Should be in the range [0 .. NumberOfTracks()-1]
 395          */
 396         const AliTrackDecision* SingleTrackDecision(Int_t i) const
 397         {
 398                 return static_cast<const AliTrackDecision*>(fTrackDecisions.At(i));
 399         }
 400
 401         /**
 402          * Returns the total number of track pairs that formed part of this trigger decision.
 403          */
 404         Int_t NumberOfPairs() const { return fPairDecisions.GetEntriesFast(); }
 405
 406         /**
 407          * Returns the i'th trigger decision for a track pair.
 408          * \param i  Should be in the range [0 .. NumberOfPairs()-1]
 409          */
 410         const AliPairDecision* TrackPairDecision(Int_t i) const
 411         {
 412                 return static_cast<const AliPairDecision*>(fPairDecisions.At(i));
 413         }
 414
 415         /// Add a single track decision to the dHLT trigger.
 416         void AddDecision(const AliTrackDecision* decision);
 417
 418         /// Add a single track decision to the dHLT trigger.
 419         void AddDecision(
 420                         Float_t pt, Bool_t passedLowCut, Bool_t passedHighCut,
 421                         const AliHLTMUONMansoTrack* track
 422                 );
 423
 424         /// Add a track pair decision to the dHLT trigger.
 425         void AddDecision(const AliPairDecision* decision);
 426
 427         /// Add a track pair decision to the dHLT trigger.
 428         void AddDecision(
 429                         Float_t mass, Bool_t passedLowCut,
 430                         Bool_t passedHighCut, Bool_t unlike,
 431                         UChar_t lowPtCount, UChar_t highPtCount,
 432                         const AliHLTMUONMansoTrack* trackA,
 433                         const AliHLTMUONMansoTrack* trackB
 434                 );
 435
 436         /**
 437          * Prints the details of the dHLT decision to screen.
 438          * @param option  A case sensitive string that can contain one of the
 439          *     following strings:
 440          *       "compact" - Prints just the trigger scalars.
 441          *       "detail" - Prints also the track decision list in a compact format.
 442          *       "all" - Prints all decision information and also the track decision details.
 443          *     If the string contains an empty option or NULL then the default is
 444          *     to print compactly.
 445          */
 446         virtual void Print(Option_t* option = NULL) const;
 447
 448         // Methods inherited from TObject
 449         virtual Bool_t IsSortable() const { return kTRUE; }
 450         Int_t Compare(const TObject* obj) const;
 451
 452         // Implement comparison operators.
 453         bool operator == (const AliHLTMUONDecision& track) const;
 454
 455         bool operator != (const AliHLTMUONDecision& track) const
 456         {
 457                 return not this->operator == (track);
 458         }
 459
 460 private:
 461
 462         // Do not allow copying of this class.
 463         AliHLTMUONDecision(const AliHLTMUONDecision& track);
 464         AliHLTMUONDecision& operator = (const AliHLTMUONDecision& track);
 465
 466         UInt_t fNlowPt;  ///< Number of low pt triggers.
 467         UInt_t fNhighPt; ///< Number of high pt triggers.
 468
 469         /// Number of unlike sign pt triggers for both tracks having any pt.
 470         UInt_t fNunlikeAnyPt;
 471
 472         /// Number of unlike sign low pt triggers where both tracks have pt > low cut.
 473         UInt_t fNunlikeLowPt;
 474
 475         /// Number of unlike sign high pt triggers where both tracks have pt > high cut.
 476         UInt_t fNunlikeHighPt;
 477
 478         /// Number of like sign pt triggers where both tracks have any pt.
 479         UInt_t fNlikeAnyPt;
 480
 481         /// Number of like sign low pt triggers where both tracks have pt > low cut.
 482         UInt_t fNlikeLowPt;
 483
 484         /// Number of like sign high pt triggers where both tracks have pt > high cut.
 485         UInt_t fNlikeHighPt;
 486
 487         /// Number of pairs that have invariant mass > low mass cut, any pt and unlike sign.
 488         UInt_t fNmassAny;
 489
 490         /// Number of pairs that have invariant mass > low mass cut, pt > low pt cut and unlike sign.
 491         UInt_t fNmassLow;
 492
 493         /// Number of pairs that have invariant mass > high mass cut, pt > high pt cut and unlike sign.
 494         UInt_t fNmassHigh;
 495
 496         TClonesArray fTrackDecisions;  ///< Array of single track decision objects.
 497         TClonesArray fPairDecisions;  ///< Array of track pair decision objects.
 498
 499         ClassDef(AliHLTMUONDecision, 3); // Decision object containing data converted from raw internal dHLT data structures.
 500 };
 501
 502 #endif // ALIHLTMUONDECISION_H