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 //_____________________________________________________________________________
 244 Bool_t
 245 AliMUONDigit::IsUsed() const
 246 {
 247   /// Whether this digit is used or not (in a cluster, for instance)
 248
 249   return (fFlags & fgkUsedMask );
 250 }
 251
 252 //_____________________________________________________________________________
 253 Bool_t
 254 AliMUONDigit::IsEfficiencyApplied() const
 255 {
 256   /// Whether this digit had efficiency applied or not
 257
 258   return (fFlags & fgkEfficiencyMask );
 259 }
 260
 261 //_____________________________________________________________________________
 262 void
 263 AliMUONDigit::Used(Bool_t value)
 264 {
 265   /// Set the Used status of this digit.
 266
 267   if ( value )
 268   {
 269     fFlags |= fgkUsedMask;
 270   }
 271   else
 272   {
 273     fFlags &= ~fgkUsedMask;
 274   }
 275 }
 276
 277 //_____________________________________________________________________________
 278 void
 279 AliMUONDigit::Calibrated(Bool_t value)
 280 {
 281   /// Set the Calibrated status of this digit.
 282
 283   if ( value )
 284   {
 285     fFlags |= fgkCalibratedMask;
 286   }
 287   else
 288   {
 289     fFlags &= ~fgkCalibratedMask;
 290   }
 291 }
 292
 293 //_____________________________________________________________________________
 294 void
 295 AliMUONDigit::EfficiencyApplied(Bool_t value)
 296 {
 297   /// Set the EfficiencyApplied status of this digit.
 298
 299   if ( value )
 300   {
 301     fFlags |= fgkEfficiencyMask;
 302   }
 303   else
 304   {
 305     fFlags &= ~fgkEfficiencyMask;
 306   }
 307 }
 308
 309 //_____________________________________________________________________________
 310 Bool_t
 311 AliMUONDigit::MergeWith(const AliMUONVDigit& src)
 312 {
 313   /// Merge with src.
 314
 315   Bool_t check = ( src.DetElemId() == DetElemId() &&
 316                    src.PadX() == PadX() &&
 317                    src.PadY() == PadY() &&
 318                    src.Cathode() == Cathode() );
 319   if (!check)
 320   {
 321     return kFALSE;
 322   }
 323
 324   AddCharge(src.Charge());
 325   for ( Int_t i = 0; i < src.Ntracks(); ++i )
 326   {
 327     AddTrack(src.Track(i),src.TrackCharge(i));
 328   }
 329   return kTRUE;
 330 }
 331
 332 //_____________________________________________________________________________
 333 void
 334 AliMUONDigit::NoiseOnly(Bool_t value)
 335 {
 336   /// Set the NoiseOnly status of this digit.
 337
 338   if ( value )
 339   {
 340     fFlags |= fgkNoiseOnlyMask;
 341   }
 342   else
 343   {
 344     fFlags &= ~fgkNoiseOnlyMask;
 345   }
 346 }
 347
 348 //_____________________________________________________________________________
 349 AliMUONDigit&
 350 AliMUONDigit::operator=(const AliMUONDigit& digit)
 351 {
 352   /// Assignement operator.
 353
 354   if ( this != &digit )
 355   {
 356     digit.Copy(*this);
 357   }
 358   return *this;
 359 }
 360
 361 //_____________________________________________________________________________
 362 void
 363 AliMUONDigit::PatchTracks(Int_t mask)
 364 {
 365   /// Add mask to each track number.
 366
 367   for ( Int_t i = 0; i < Ntracks(); ++i )
 368   {
 369     fTracks[i] += mask;
 370   }
 371 }
 372
 373 //_____________________________________________________________________________
 374 void
 375 AliMUONDigit::Saturated(Bool_t value)
 376 {
 377   /// Set the saturation status of this digit.
 378
 379   if ( value )
 380   {
 381     fFlags |= fgkSaturatedMask;
 382   }
 383   else
 384   {
 385     fFlags &= ~fgkSaturatedMask;
 386   }
 387 }
 388
 389 //_____________________________________________________________________________
 390 Int_t
 391 AliMUONDigit::Track(Int_t i) const
 392 {
 393   /// Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
 394
 395   if ( i >= 0 && i < fNtracks )
 396   {
 397     return fTracks[i];
 398   }
 399
 400   return -1;
 401 }
 402
 403 //_____________________________________________________________________________
 404 Float_t
 405 AliMUONDigit::TrackCharge(Int_t i) const
 406 {
 407   /// Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
 408
 409   if ( i >= 0 && i < fNtracks )
 410   {
 411     return fTcharges[i];
 412   }
 413
 414   return -1;
 415 }
 416
 417 //_____________________________________________________________________________
 418 UInt_t
 419 AliMUONDigit::GetUniqueID() const
 420 {
 421   /// Return a single integer with id information
 422
 423   return BuildUniqueID(DetElemId(),ManuId(),ManuChannel(),Cathode());
 424 }