MUON/AliMUONDigit.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 #include "AliMUONDigit.h"
  19
  20 //-----------------------------------------------------------------------------
  21 /// \class AliMUONDigit
  22 /// A class representing a digit (with MC information if possible)
  23 /// in the MUON spectrometer either in tracking or trigger chambers.
  24 ///
  25 /// A digit holds the signal (proportional to a charge) on a pad
  26 /// (or strip).
  27 ///
  28 /// This class is used to represent either sdigits (purely simulated digit,
  29 /// with no electronic noise whatsoever) or digits (simulated ones but
  30 /// including electronic noise and de-calibration, to closely ressemble real ones).
  31 //-----------------------------------------------------------------------------
  32
  33 /// \cond CLASSIMP
  34 ClassImp(AliMUONDigit)
  35 /// \endcond
  36
  37 //_____________________________________________________________________________
  38 AliMUONDigit::AliMUONDigit()
  39 :
  40 AliMUONVDigit(),
  41 fDetElemId(0),
  42 fManuId(0),
  43 fManuChannel(0),
  44 fSignal(0.0),
  45 fPadX(-1),
  46 fPadY(-1),
  47 fCathode(0),
  48 fADC(0),
  49 fFlags(0),
  50 fNtracks(0),
  51 fTcharges(0x0),
  52 fTracks(0x0),
  53 fHit(0),
  54 fTime(0),
  55 fStatusMap(0)
  56 {
  57   /// Default constructor
  58 }
  59
  60 //_____________________________________________________________________________
  61 AliMUONDigit::AliMUONDigit(Int_t detElemId, Int_t manuId,
  62                            Int_t manuChannel, Int_t cathode)
  63 :
  64 AliMUONVDigit(detElemId,manuId,manuChannel,cathode),
  65 fDetElemId(detElemId),
  66 fManuId(manuId),
  67 fManuChannel(manuChannel),
  68 fSignal(0.0),
  69 fPadX(-1),
  70 fPadY(-1),
  71 fCathode(cathode),
  72 fADC(0),
  73 fFlags(0),
  74 fNtracks(0),
  75 fTcharges(0x0),
  76 fTracks(0x0),
  77 fHit(0),
  78 fTime(0),
  79 fStatusMap(0)
  80 {
  81   /// Normal constructor
  82 }
  83
  84
  85 //_____________________________________________________________________________
  86 AliMUONDigit::AliMUONDigit(const AliMUONDigit& digit)
  87 : AliMUONVDigit(),
  88 fDetElemId(0),
  89 fManuId(0),
  90 fManuChannel(0),
  91 fSignal(0.0),
  92 fPadX(-1),
  93 fPadY(-1),
  94 fCathode(0),
  95 fADC(0),
  96 fFlags(0),
  97 fNtracks(0),
  98 fTcharges(0x0),
  99 fTracks(0x0),
 100 fHit(0),
 101 fTime(0),
 102 fStatusMap(0)
 103 {
 104   /// Copy constructor
 105
 106    (static_cast<const AliMUONDigit&>(digit)).Copy(*this);
 107 }
 108
 109 //_____________________________________________________________________________
 110 AliMUONDigit::~AliMUONDigit()
 111 {
 112   /// Destructor
 113
 114   delete[] fTcharges;
 115   delete[] fTracks;
 116 }
 117
 118 //_____________________________________________________________________________
 119 void
 120 AliMUONDigit::AddTrack(Int_t trackNumber, Float_t trackCharge)
 121 {
 122   /// Add 1 track information to the track list we keep.
 123   /// The implementation below is dumb, you've been warned !
 124
 125   // First check if track is already there, in which
 126   // case we simply increment its charge.
 127   for ( Int_t i = 0; i < Ntracks(); ++i )
 128   {
 129       if ( Track(i) == trackNumber )
 130       {
 131         fTcharges[i] += trackCharge;
 132         return;
 133       }
 134   }
 135
 136   // Nope. It's a brand new track. Make a new array to get space
 137   // for it, copy the old array into new one, and add the track.
 138   Int_t* newTracks = new Int_t[fNtracks+1];
 139   Float_t* newTcharges = new Float_t[fNtracks+1];
 140
 141   for ( Int_t i = 0; i < fNtracks; ++i )
 142   {
 143     newTracks[i] = fTracks[i];
 144     newTcharges[i] = fTcharges[i];
 145   }
 146
 147   newTracks[fNtracks] = trackNumber;
 148   newTcharges[fNtracks] = trackCharge;
 149
 150   delete[] fTracks;
 151   delete[] fTcharges;
 152
 153   fTracks = newTracks;
 154   fTcharges = newTcharges;
 155
 156   ++fNtracks;
 157 }
 158
 159 //_____________________________________________________________________________
 160 void
 161 AliMUONDigit::Clear(Option_t*)
 162 {
 163   /// Reset this digit, in particular the internal arrays are deleted.
 164
 165   delete[] fTracks;
 166   delete[] fTcharges;
 167   fTracks=0x0;
 168   fTcharges=0x0;
 169   fNtracks=0;
 170 }
 171
 172 //______________________________________________________________________________
 173 void
 174 AliMUONDigit::Copy(TObject& obj) const
 175 {
 176   /// Copy this line to line.
 177
 178   TObject::Copy(obj);
 179   AliMUONDigit& digit = static_cast<AliMUONDigit&>(obj);
 180
 181   digit.fDetElemId = fDetElemId;
 182   digit.fManuId = fManuId;
 183   digit.fManuChannel = fManuChannel;
 184   digit.fSignal = fSignal;
 185
 186   digit.fPadX = fPadX;
 187   digit.fPadY = fPadY;
 188   digit.fCathode = fCathode;
 189   digit.fADC = fADC;
 190   digit.fFlags = fFlags;
 191
 192   digit.fNtracks = fNtracks;
 193
 194   delete[] digit.fTcharges;
 195   delete[] digit.fTracks;
 196
 197   if ( fNtracks )
 198   {
 199     digit.fTcharges = new Float_t[fNtracks];
 200     digit.fTracks = new Int_t[fNtracks];
 201   }
 202
 203   for ( Int_t i=0; i<fNtracks; ++i )
 204   {
 205     digit.fTcharges[i] = fTcharges[i];
 206     digit.fTracks[i] = fTracks[i];
 207   }
 208
 209   digit.fHit = fHit;
 210   digit.fTime = fTime;
 211   digit.fStatusMap = fStatusMap;
 212 }
 213
 214
 215 //_____________________________________________________________________________
 216 Bool_t
 217 AliMUONDigit::IsNoiseOnly() const
 218 {
 219   /// Whether this (simulated only) digit is only due to noise.
 220
 221   return (fFlags & fgkNoiseOnlyMask );
 222 }
 223
 224 //_____________________________________________________________________________
 225 Bool_t
 226 AliMUONDigit::IsSaturated() const
 227 {
 228   /// Whether this digit is saturated or not.
 229
 230   return (fFlags & fgkSaturatedMask );
 231 }
 232
 233 //_____________________________________________________________________________
 234 Bool_t
 235 AliMUONDigit::IsCalibrated() const
 236 {
 237   /// Whether this digit is calibrated or not
 238
 239   return (fFlags & fgkCalibratedMask );
 240 }
 241
 242 //_____________________________________________________________________________
 243 Bool_t
 244 AliMUONDigit::IsConverted() const
 245 {
 246   /// Whether this digit is converted or not
 247
 248   return (fFlags & fgkConverted);
 249 }
 250
 251
 252 //_____________________________________________________________________________
 253 Bool_t
 254 AliMUONDigit::IsUsed() const
 255 {
 256   /// Whether this digit is used or not (in a cluster, for instance)
 257
 258   return (fFlags & fgkUsedMask );
 259 }
 260
 261 //_____________________________________________________________________________
 262 Bool_t
 263 AliMUONDigit::IsEfficiencyApplied() const
 264 {
 265   /// Whether this digit had efficiency applied or not
 266
 267   return (fFlags & fgkEfficiencyMask );
 268 }
 269
 270 //_____________________________________________________________________________
 271 void
 272 AliMUONDigit::Used(Bool_t value)
 273 {
 274   /// Set the Used status of this digit.
 275
 276   if ( value )
 277   {
 278     fFlags |= fgkUsedMask;
 279   }
 280   else
 281   {
 282     fFlags &= ~fgkUsedMask;
 283   }
 284 }
 285
 286 //_____________________________________________________________________________
 287 void
 288 AliMUONDigit::Calibrated(Bool_t value)
 289 {
 290   /// Set the Calibrated status of this digit.
 291
 292   if ( value )
 293   {
 294     fFlags |= fgkCalibratedMask;
 295   }
 296   else
 297   {
 298     fFlags &= ~fgkCalibratedMask;
 299   }
 300 }
 301
 302 //_____________________________________________________________________________
 303 void
 304 AliMUONDigit::EfficiencyApplied(Bool_t value)
 305 {
 306   /// Set the EfficiencyApplied status of this digit.
 307
 308   if ( value )
 309   {
 310     fFlags |= fgkEfficiencyMask;
 311   }
 312   else
 313   {
 314     fFlags &= ~fgkEfficiencyMask;
 315   }
 316 }
 317
 318 //_____________________________________________________________________________
 319 Bool_t
 320 AliMUONDigit::MergeWith(const AliMUONVDigit& src)
 321 {
 322   /// Merge with src.
 323
 324   Bool_t check = ( src.DetElemId() == DetElemId() &&
 325                    src.PadX() == PadX() &&
 326                    src.PadY() == PadY() &&
 327                    src.Cathode() == Cathode() );
 328   if (!check)
 329   {
 330     return kFALSE;
 331   }
 332
 333   AddCharge(src.Charge());
 334   for ( Int_t i = 0; i < src.Ntracks(); ++i )
 335   {
 336     AddTrack(src.Track(i),src.TrackCharge(i));
 337   }
 338   return kTRUE;
 339 }
 340
 341 //_____________________________________________________________________________
 342 void
 343 AliMUONDigit::NoiseOnly(Bool_t value)
 344 {
 345   /// Set the NoiseOnly status of this digit.
 346
 347   if ( value )
 348   {
 349     fFlags |= fgkNoiseOnlyMask;
 350   }
 351   else
 352   {
 353     fFlags &= ~fgkNoiseOnlyMask;
 354   }
 355 }
 356
 357 //_____________________________________________________________________________
 358 AliMUONDigit&
 359 AliMUONDigit::operator=(const AliMUONDigit& digit)
 360 {
 361   /// Assignement operator.
 362
 363   if ( this != &digit )
 364   {
 365     digit.Copy(*this);
 366   }
 367   return *this;
 368 }
 369
 370 //_____________________________________________________________________________
 371 void
 372 AliMUONDigit::PatchTracks(Int_t mask)
 373 {
 374   /// Add mask to each track number.
 375
 376   for ( Int_t i = 0; i < Ntracks(); ++i )
 377   {
 378     fTracks[i] += mask;
 379   }
 380 }
 381
 382 //_____________________________________________________________________________
 383 void
 384 AliMUONDigit::Saturated(Bool_t value)
 385 {
 386   /// Set the saturation status of this digit.
 387
 388   if ( value )
 389   {
 390     fFlags |= fgkSaturatedMask;
 391   }
 392   else
 393   {
 394     fFlags &= ~fgkSaturatedMask;
 395   }
 396 }
 397
 398 //_____________________________________________________________________________
 399 void
 400 AliMUONDigit::Converted(Bool_t value)
 401 {
 402   /// Set the convertion status of this digit.
 403
 404   if ( value )
 405   {
 406     fFlags |= fgkConverted;
 407   }
 408   else
 409   {
 410     fFlags &= ~fgkConverted;
 411   }
 412 }
 413
 414 //_____________________________________________________________________________
 415 Int_t
 416 AliMUONDigit::Track(Int_t i) const
 417 {
 418   /// Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
 419
 420   if ( i >= 0 && i < fNtracks )
 421   {
 422     return fTracks[i];
 423   }
 424
 425   return -1;
 426 }
 427
 428 //_____________________________________________________________________________
 429 Float_t
 430 AliMUONDigit::TrackCharge(Int_t i) const
 431 {
 432   /// Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
 433
 434   if ( i >= 0 && i < fNtracks )
 435   {
 436     return fTcharges[i];
 437   }
 438
 439   return -1;
 440 }
 441
 442 //_____________________________________________________________________________
 443 UInt_t
 444 AliMUONDigit::GetUniqueID() const
 445 {
 446   /// Return a single integer with id information
 447
 448   return BuildUniqueID(DetElemId(),ManuId(),ManuChannel(),Cathode());
 449 }