Corrected assignment operator:
[u/mrichter/AliRoot.git] / 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 fStatusMap(0)
55 {
56   /// Default constructor
57 }
58
59 //_____________________________________________________________________________
60 AliMUONDigit::AliMUONDigit(Int_t detElemId, Int_t manuId,
61                            Int_t manuChannel, Int_t cathode)
62
63 AliMUONVDigit(detElemId,manuId,manuChannel,cathode),
64 fDetElemId(detElemId),
65 fManuId(manuId),
66 fManuChannel(manuChannel),
67 fSignal(0.0),
68 fPadX(-1),
69 fPadY(-1),
70 fCathode(cathode),
71 fADC(0),
72 fFlags(0),
73 fNtracks(0),
74 fTcharges(0x0),
75 fTracks(0x0),
76 fHit(0),
77 fStatusMap(0)
78 {
79   /// Normal constructor
80 }
81
82
83 //_____________________________________________________________________________
84 AliMUONDigit::AliMUONDigit(const AliMUONDigit& digit)
85 : AliMUONVDigit(),
86 fDetElemId(0),
87 fManuId(0),
88 fManuChannel(0),
89 fSignal(0.0),
90 fPadX(-1),
91 fPadY(-1),
92 fCathode(0),
93 fADC(0),
94 fFlags(0),
95 fNtracks(0),
96 fTcharges(0x0),
97 fTracks(0x0),
98 fHit(0),
99 fStatusMap(0)
100 {
101   /// Copy constructor
102
103    (static_cast<const AliMUONDigit&>(digit)).Copy(*this);
104 }
105
106 //_____________________________________________________________________________
107 AliMUONDigit::~AliMUONDigit()
108 {
109   /// Destructor 
110
111   delete[] fTcharges;
112   delete[] fTracks;
113 }
114
115 //_____________________________________________________________________________
116 void
117 AliMUONDigit::AddTrack(Int_t trackNumber, Float_t trackCharge)
118 {
119   /// Add 1 track information to the track list we keep.
120   /// The implementation below is dumb, you've been warned !
121   
122   // First check if track is already there, in which
123   // case we simply increment its charge.
124   for ( Int_t i = 0; i < Ntracks(); ++i )
125   {
126       if ( Track(i) == trackNumber ) 
127       {
128         fTcharges[i] += trackCharge;
129         return;
130       }
131   }
132   
133   // Nope. It's a brand new track. Make a new array to get space
134   // for it, copy the old array into new one, and add the track.
135   Int_t* newTracks = new Int_t[fNtracks+1];
136   Float_t* newTcharges = new Float_t[fNtracks+1];
137   
138   for ( Int_t i = 0; i < fNtracks; ++i )
139   {
140     newTracks[i] = fTracks[i];
141     newTcharges[i] = fTcharges[i];
142   }
143   
144   newTracks[fNtracks] = trackNumber;
145   newTcharges[fNtracks] = trackCharge;
146   
147   delete[] fTracks;
148   delete[] fTcharges;
149   
150   fTracks = newTracks;
151   fTcharges = newTcharges;
152   
153   ++fNtracks;
154 }
155
156 //_____________________________________________________________________________
157 void 
158 AliMUONDigit::Clear(Option_t*)
159 {
160   /// Reset this digit, in particular the internal arrays are deleted.
161
162   delete[] fTracks;
163   delete[] fTcharges;
164   fTracks=0x0;
165   fTcharges=0x0;
166   fNtracks=0;
167 }
168
169 //______________________________________________________________________________
170 void 
171 AliMUONDigit::Copy(TObject& obj) const
172 {
173   /// Copy this line to line.
174
175   TObject::Copy(obj);
176   AliMUONDigit& digit = static_cast<AliMUONDigit&>(obj);
177   
178   digit.fDetElemId = fDetElemId;
179   digit.fManuId = fManuId;
180   digit.fManuChannel = fManuChannel;
181   digit.fSignal = fSignal;
182   
183   digit.fPadX = fPadX;
184   digit.fPadY = fPadY;
185   digit.fCathode = fCathode;
186   digit.fADC = fADC;
187   digit.fFlags = fFlags;
188   
189   digit.fNtracks = fNtracks;
190   
191   delete[] digit.fTcharges;
192   delete[] digit.fTracks;
193   
194   if ( fNtracks )
195   {
196     digit.fTcharges = new Float_t[fNtracks];
197     digit.fTracks = new Int_t[fNtracks];
198   }
199   
200   for ( Int_t i=0; i<fNtracks; ++i ) 
201   {
202     digit.fTcharges[i] = fTcharges[i];
203     digit.fTracks[i] = fTracks[i];
204   }
205   
206   digit.fHit = fHit;
207   digit.fStatusMap = fStatusMap;
208 }
209
210
211 //_____________________________________________________________________________
212 Bool_t
213 AliMUONDigit::IsNoiseOnly() const
214 {
215   /// Whether this (simulated only) digit is only due to noise.
216
217   return (fFlags & fgkNoiseOnlyMask );
218 }
219
220 //_____________________________________________________________________________
221 Bool_t
222 AliMUONDigit::IsSaturated() const
223 {
224   /// Whether this digit is saturated or not.
225
226   return (fFlags & fgkSaturatedMask );
227 }
228
229 //_____________________________________________________________________________
230 Bool_t
231 AliMUONDigit::IsCalibrated() const
232 {
233   /// Whether this digit is calibrated or not
234   
235   return (fFlags & fgkCalibratedMask );
236 }
237
238
239 //_____________________________________________________________________________
240 Bool_t
241 AliMUONDigit::IsUsed() const
242 {
243   /// Whether this digit is used or not (in a cluster, for instance)
244   
245   return (fFlags & fgkUsedMask );
246 }
247
248 //_____________________________________________________________________________
249 Bool_t
250 AliMUONDigit::IsEfficiencyApplied() const
251 {
252   /// Whether this digit had efficiency applied or not
253   
254   return (fFlags & fgkEfficiencyMask );
255 }
256
257 //_____________________________________________________________________________
258 void
259 AliMUONDigit::Used(Bool_t value)
260 {
261   /// Set the Used status of this digit.
262   
263   if ( value )
264   {
265     fFlags |= fgkUsedMask;
266   }
267   else
268   {
269     fFlags ^= fgkUsedMask;
270   }
271 }
272
273 //_____________________________________________________________________________
274 void
275 AliMUONDigit::Calibrated(Bool_t value)
276 {
277   /// Set the Calibrated status of this digit.
278   
279   if ( value )
280   {
281     fFlags |= fgkCalibratedMask;
282   }
283   else
284   {
285     fFlags ^= fgkCalibratedMask;
286   }
287 }
288
289 //_____________________________________________________________________________
290 void
291 AliMUONDigit::EfficiencyApplied(Bool_t value)
292 {
293   /// Set the EfficiencyApplied status of this digit.
294   
295   if ( value )
296   {
297     fFlags |= fgkEfficiencyMask;
298   }
299   else
300   {
301     fFlags ^= fgkEfficiencyMask;
302   }
303 }
304
305 //_____________________________________________________________________________
306 Bool_t
307 AliMUONDigit::MergeWith(const AliMUONVDigit& src)
308 {
309   /// Merge with src.
310   
311   Bool_t check = ( src.DetElemId() == DetElemId() &&
312                    src.PadX() == PadX() &&
313                    src.PadY() == PadY() &&
314                    src.Cathode() == Cathode() );
315   if (!check)
316   {
317     return kFALSE;
318   }
319   
320   AddCharge(src.Charge());
321   for ( Int_t i = 0; i < src.Ntracks(); ++i )
322   {
323     AddTrack(src.Track(i),src.TrackCharge(i));
324   }
325   return kTRUE;
326 }
327
328 //_____________________________________________________________________________
329 void
330 AliMUONDigit::NoiseOnly(Bool_t value)
331 {
332   /// Set the NoiseOnly status of this digit.
333
334   if ( value )
335   {
336     fFlags |= fgkNoiseOnlyMask;
337   }
338   else
339   {
340     fFlags ^= fgkNoiseOnlyMask;
341   }
342 }
343
344 //_____________________________________________________________________________
345 AliMUONDigit& 
346 AliMUONDigit::operator=(const AliMUONDigit& digit)
347 {
348   /// Assignement operator.
349
350   if ( this != &digit ) 
351   {
352     digit.Copy(*this);
353   }
354   return *this;
355 }
356
357 //_____________________________________________________________________________
358 void
359 AliMUONDigit::PatchTracks(Int_t mask)
360 {
361   /// Add mask to each track number.
362
363   for ( Int_t i = 0; i < Ntracks(); ++i )
364   {
365     fTracks[i] += mask;
366   }
367 }
368
369 //_____________________________________________________________________________
370 void
371 AliMUONDigit::Saturated(Bool_t value)
372 {
373   /// Set the saturation status of this digit.
374
375   if ( value )
376   {
377     fFlags |= fgkSaturatedMask;
378   }
379   else
380   {
381     fFlags ^= fgkSaturatedMask;
382   }
383 }
384
385 //_____________________________________________________________________________
386 Int_t
387 AliMUONDigit::Track(Int_t i) const
388 {
389   /// Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
390
391   if ( i >= 0 && i < fNtracks ) 
392   {
393     return fTracks[i];
394   }
395
396   return -1;
397 }
398
399 //_____________________________________________________________________________
400 Float_t
401 AliMUONDigit::TrackCharge(Int_t i) const
402 {
403   /// Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
404
405   if ( i >= 0 && i < fNtracks ) 
406   {
407     return fTcharges[i];
408   }
409
410   return -1;
411 }
412
413 //_____________________________________________________________________________
414 UInt_t
415 AliMUONDigit::GetUniqueID() const
416 {
417   /// Return a single integer with id information
418
419   return BuildUniqueID(DetElemId(),ManuId(),ManuChannel(),Cathode());
420 }