HLT/MUON/AliHLTMUONRecHit.h

   1 #ifndef ALIHLTMUONRECHIT_H
   2 #define ALIHLTMUONRECHIT_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   AliHLTMUONRecHit.h
  11 /// @author Artur Szostak <artursz@iafrica.com>
  12 /// @date   29 Sep 2007
  13 /// @brief  Declaration of a reconstructed hit ROOT object to store 3D hit coordinates.
  14 ///
  15
  16 #include "TObject.h"
  17 #include "TClonesArray.h"
  18 #include "TVector3.h"
  19 #include <ostream>
  20
  21 /**
  22  * A 3D hit object used to store hits reconstructed on the tracking chambers by
  23  * the dHLT. These objects store information translated into ROOT format from
  24  * dHLT raw data. Reconstructed hit values of (0, 0, 0) indicate an invalid or
  25  * nil hit.
  26  * This class is mainly for testing or as a helper object for dHLT specific analysis,
  27  * since it is sometimes easier to store and handle ROOT objects.
  28  */
  29 class AliHLTMUONRecHit : public TObject
  30 {
  31         /**
  32          * Stream operator for usage with std::ostream classes.
  33          * Allows usage such as:
  34          *   AliHLTMUONRecHit h; std::cout << h;
  35          */
  36         friend std::ostream& operator << (std::ostream& stream, const AliHLTMUONRecHit& hit);
  37
  38 public:
  39
  40         /**
  41          * The AliChannel class stores extra debugging information about the channels
  42          * and raw data words that were considered during reconstruction of a hit
  43          * by the dHLT hit reconstructor component.
  44          */
  45         class AliChannel : public TObject
  46         {
  47                 /**
  48                  * Stream operator for usage with std::ostream classes.
  49                  */
  50                 friend std::ostream& operator << (std::ostream& stream, const AliChannel& c);
  51
  52         public:
  53
  54                 /**
  55                  * Constructor.
  56                  * \param busPatch  The bus patch ID of the channel as found in the DDL raw data.
  57                  * \param manu  The MANU ID of the channel as found in the raw data word.
  58                  * \param channel  The MANU channel ID as found in the raw data word.
  59                  * \param signal  The ADC signal value as found in the raw data word.
  60                  * \param rawDataWord  The actual raw data word.
  61                  */
  62                 AliChannel(
  63                                 Short_t busPatch = -1,
  64                                 Short_t manu = -1,
  65                                 Short_t channel = -1,
  66                                 Short_t signal = -1,
  67                                 UInt_t rawDataWord = 0
  68                         ) :
  69                         TObject(), fBusPatch(busPatch),
  70                         fManu(manu), fAddress(channel), fSignal(signal),
  71                         fRawDataWord(rawDataWord)
  72                 {}
  73
  74                 /**
  75                  * Default destructor.
  76                  */
  77                 virtual ~AliChannel() {}
  78
  79                 /**
  80                  * Returns the bus patch ID of the channel.
  81                  */
  82                 Short_t BusPatch() const { return fBusPatch; }
  83
  84                 /**
  85                  * Returns the MANU address.
  86                  */
  87                 Short_t Manu() const { return fManu; }
  88
  89                 /**
  90                  * Returns the channel address of the MANU.
  91                  */
  92                 Short_t Address() const { return fAddress; }
  93
  94                 /**
  95                  * Returns the ADC signal measured on the channel.
  96                  */
  97                 Short_t Signal() const { return fSignal; }
  98
  99                 /**
 100                  * Returns the raw data word as found in the tracking DDL payload.
 101                  */
 102                 UInt_t RawDataWord() const { return fRawDataWord; }
 103
 104                 /**
 105                  * Returns true if the channel is for the bending plane.
 106                  */
 107                 Bool_t InBendingPlane() const { return (fRawDataWord & (1<<28)) == 0; }
 108
 109                 /**
 110                  * Returns true if the channel is for the non-bending plane.
 111                  */
 112                 Bool_t InNonBendingPlane() const { return (fRawDataWord & (1<<28)) != 0; }
 113
 114                 virtual void Print(Option_t* option = NULL) const;
 115
 116                 // Methods inherited from TObject
 117                 virtual Bool_t IsSortable() const { return kTRUE; }
 118                 Int_t Compare(const TObject* obj) const;
 119
 120                 // Implement comparison operators.
 121                 bool operator == (const AliChannel& c) const
 122                 {
 123                         return fManu == c.fManu and fAddress == c.fAddress
 124                                 and fSignal == c.fSignal
 125                                 and fRawDataWord == c.fRawDataWord;
 126                 }
 127
 128                 bool operator != (const AliChannel& c) const
 129                 {
 130                         return not this->operator == (c);
 131                 }
 132
 133         private:
 134
 135                 Short_t fBusPatch;   ///< The bus patch ID for the channel.
 136                 Short_t fManu;       ///< The MANU address on the electronics.
 137                 Short_t fAddress;    ///< The channel address on the electronics.
 138                 Short_t fSignal;     ///< ADC value of signal.
 139                 UInt_t fRawDataWord; ///< The raw data word as found in the DDL stream.
 140
 141                 ClassDef(AliHLTMUONRecHit::AliChannel, 5); // A MANU channel forming part of a cluster that was considered during hit reconstruction in dHLT.
 142         };
 143
 144         /**
 145          * Construct a new AliHLTMUONRecHit object with coordinate (x, y, z).
 146          * @param x           X coordinate of hit
 147          * @param y           Y coordinate of hit
 148          * @param z           Z coordinate of hit
 149          * @param sourceDDL   The DDL from which this hit originates.
 150          * @param detectorId  The ID number for the AliRoot detector element on
 151          *                    which this hit resides.
 152          * @param clusterId   The cluster ID number assigned to the hit's cluster.
 153          * @param nChExpB     The expected number of channels in the bending plane that form the cluster.
 154          * @param nChExpNB    The expected number of channels in the non-bending plane that form the cluster.
 155          * @param chargeB     The charge of the cluster in the bending plane.
 156          * @param chargeNB    The charge of the cluster in the non-bending plane.
 157          */
 158         AliHLTMUONRecHit(
 159                         Float_t x = 0,
 160                         Float_t y = 0,
 161                         Float_t z = 0,
 162                         Int_t sourceDDL = -1,
 163                         Int_t detElemId = -1,
 164                         Int_t clusterId = -1,
 165                         UShort_t nChExpB = 0,
 166                         UShort_t nChExpNB = 0,
 167                         Float_t chargeB = -1,
 168                         Float_t chargeNB = -1
 169                 ) :
 170                 TObject(), fCoordinate(x, y, z), fSourceDDL(sourceDDL),
 171                 fDetElemId(detElemId), fClusterId(clusterId), fNchExpB(nChExpB),
 172                 fNchExpNB(nChExpNB), fChannels("AliHLTMUONRecHit::AliChannel", 6),
 173                 fChargeB(chargeB), fChargeNB(chargeNB)
 174         {}
 175
 176         /**
 177          * Default destructor.
 178          */
 179         virtual ~AliHLTMUONRecHit() {}
 180
 181         /**
 182          * Returns the 3D hit coordinate.
 183          */
 184         const TVector3& Coordinate() const { return fCoordinate; }
 185
 186         /**
 187          * Returns the X coordinate of the reconstructed hit in centimetres.
 188          */
 189         Double_t X() const { return fCoordinate.X(); }
 190
 191         /**
 192          * Returns the Y coordinate of the reconstructed hit in centimetres.
 193          */
 194         Double_t Y() const { return fCoordinate.Y(); }
 195
 196         /**
 197          * Returns the Z coordinate of the reconstructed hit in centimetres.
 198          */
 199         Double_t Z() const { return fCoordinate.Z(); }
 200
 201         /**
 202          * Returns the source DDL from which this hit originates.
 203          * -1 is returned if this was not set.
 204          */
 205         Int_t SourceDDL() const { return fSourceDDL; }
 206
 207         /**
 208          * Returns the detector element ID on which this reconstructed hit resides.
 209          * -1 is returned if this was not set.
 210          */
 211         Int_t DetElemId() const { return fDetElemId; }
 212
 213         /**
 214          * Returns the chamber number of this hit in the range [1..14].
 215          * If -1 is returned then the chamber number is not known because the
 216          * detector element ID was not set or is invalid.
 217          * @param warn  Indicates if any warning should be printed in case of problems.
 218          */
 219         Int_t Chamber(bool warn = true) const;
 220
 221         /**
 222          * Returns the ID number given to the hit's cluster.
 223          */
 224         Int_t ClusterId() const { return fClusterId; }
 225
 226         /**
 227          * Returns the expected total number of channels that are to be added to this hit.
 228          * If the number of calls to AddChannel does not correspond to this value
 229          * then we lost some debugging information along the way.
 230          */
 231         UInt_t ExpectedNchannels() const { return ExpectedNchannelsB() + ExpectedNchannelsNB(); }
 232
 233         /**
 234          * Returns the expected number of channels in the bending plane that are to
 235          * be added to this hit.
 236          */
 237         UInt_t ExpectedNchannelsB() const { return fNchExpB; }
 238
 239         /**
 240          * Returns the expected number of channels in the non-bending plane that
 241          * are to be added to this hit.
 242          */
 243         UInt_t ExpectedNchannelsNB() const { return fNchExpNB; }
 244
 245         /**
 246          * Returns the total charge of the cluster.
 247          */
 248         Float_t TotalCharge() const { return fChargeB + fChargeNB; }
 249
 250         /**
 251          * Returns the charge of the cluster in the bending plane.
 252          */
 253         Float_t ChargeB() const { return fChargeB; }
 254
 255         /**
 256          * Returns the charge of the cluster in the non-bending plane.
 257          */
 258         Float_t ChargeNB() const { return fChargeNB; }
 259
 260         /**
 261          * Sets the extra debugging information for this hit.
 262          * @param detElemId  The detector element ID.
 263          * @param clusterId  Cluster ID of the hit's cluster.
 264          * @param nChExpB    Number of expected channels in the bending plane forming the cluster.
 265          * @param nChExpNB   Number of expected channels in the non-bending plane forming the cluster.
 266          * @param chargeB    The charge of the cluster in the bending plane.
 267          * @param chargeNB   The charge of the cluster in the non-bending plane.
 268          * @param sourceDDL  The source DDL of this hit.
 269          */
 270         void SetDebugInfo(
 271                         Int_t detElemId, Int_t clusterId,
 272                         UShort_t nChExpB, UShort_t nChExpNB,
 273                         Float_t chargeB, Float_t chargeNB,
 274                         Int_t sourceDDL = -1
 275                 );
 276
 277         /**
 278          * Sets the hit coordinate.
 279          */
 280         void SetHit(Float_t x, Float_t y, Float_t z)
 281         {
 282                 fCoordinate.SetXYZ(x, y, z);
 283         }
 284
 285         /**
 286          * Returns the total number of channels associated with this hit.
 287          */
 288         Int_t Nchannels() const { return fChannels.GetEntriesFast(); }
 289
 290         /**
 291          * Returns the i'th channel associated with this hit.
 292          * @param i  Should be a number in the range [0..n), where n = Nchannels().
 293          */
 294         const AliChannel* GetChannel(Int_t i) const
 295         {
 296                 return static_cast<const AliChannel*>(fChannels[i]);
 297         }
 298
 299         /**
 300          * Adds a new channel to this hit if it is on a tracking chamber.
 301          * @param buspatch  The bus patch ID of the channel.
 302          * @param manu    The MANU number
 303          * @param channel The MANU channel address.
 304          * @param signal  The ADC signal value measured on the channel.
 305          * @param rawDataWord This is the raw data word as read from the DDL.
 306          */
 307         void AddChannel(
 308                         Short_t buspatch, Short_t manu, Short_t channel,
 309                         Short_t signal, UInt_t rawDataWord
 310                 );
 311
 312         /**
 313          * Prints the details of the reconstructed hit.
 314          * @param option  A case sensitive string that can contain one of the
 315          *     following strings:
 316          *       "compact" - Prints just the coordinates of the hit in a terse format.
 317          *       "detail" - Prints the coordinates and detector element ID.
 318          *       "all" - Prints all known information about this hit including
 319          *               channel information forming the cluster that was reconstructed.
 320          *     If the string contains an empty option or NULL then the default is
 321          *     to print compactly.
 322          */
 323         virtual void Print(Option_t* option = NULL) const;
 324
 325         // Methods inherited from TObject
 326         virtual Bool_t IsSortable() const { return kTRUE; }
 327         Int_t Compare(const TObject* obj) const;
 328
 329         // Implement comparison operators.
 330         bool operator == (const AliHLTMUONRecHit& hit) const
 331         {
 332                 return X() == hit.X() and Y() == hit.Y() and Z() == hit.Z();
 333         }
 334
 335         bool operator != (const AliHLTMUONRecHit& hit) const
 336         {
 337                 return not this->operator == (hit);
 338         }
 339
 340 private:
 341
 342         TVector3 fCoordinate; ///< The 3D coordinate of the hit in AliRoot global coordinates (cm).
 343
 344         // The following is debugging information and may not be filled if the
 345         // dHLT components were not set to produce this information.
 346         Int_t fSourceDDL;  ///< The DDL from which this hit originates.
 347         Int_t fDetElemId;  ///< Detector element ID number.
 348         Int_t fClusterId;  ///< The cluster ID number used to relate all the channels to each other.
 349         UShort_t fNchExpB;  ///< The number of channels in the bending plane that were supposed to be found.
 350         UShort_t fNchExpNB; ///< The number of channels in the non-bending plane that were supposed to be found.
 351         TClonesArray fChannels; ///< The channels forming part of the cluster from which this hit was reconstructed.
 352         Float_t fChargeB;   ///< The charge of the cluster in the bending plane.
 353         Float_t fChargeNB;  ///< The charge of the cluster in the non-bending plane.
 354
 355         ClassDef(AliHLTMUONRecHit, 5); // A reconstructed hit translated from dHLT raw data into ROOT format.
 356 };
 357
 358 #endif // ALIHLTMUONRECHIT_H