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