PMD module
[u/mrichter/AliRoot.git] / MUON / MUONbase / 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 }