01-sep-2003 NvE Explicit initialisation of TObject() introduced in default constructo...
[u/mrichter/AliRoot.git] / RALICE / AliSignal.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 ///////////////////////////////////////////////////////////////////////////
19 // Class AliSignal
20 // Generic handling of (extrapolated) detector signals.
21 //
22 // Note :
23 // ------
24 // Signal positions (r) and reference frames (f) are specified via
25 // SetPosition(r,f) under the following conventions :
26 //
27 // f="car" ==> r is Cartesian   (x,y,z)
28 // f="sph" ==> r is Spherical   (r,theta,phi)
29 // f="cyl" ==> r is Cylindrical (rho,phi,z)
30 //
31 // The same holds for SetPositionErrors().
32 //
33 // All angles are in radians.
34 //
35 // Example :
36 // ---------
37 //
38 // AliSignal s;
39 // s.SetName("Start counter");
40 // Float_t pos[3]={-1,25,7};
41 // Float_t err[3]={0.03,0.7,0.18};
42 // Float_t signal=120.8;
43 // Float_t error=1.73;
44 // Float_t offset=-12.78;
45 // Float_t gain=250;
46 // s.SetPosition(pos,"car");
47 // s.SetPositionErrors(err,"car");
48 // s.SetSignal(signal);
49 // s.SetSignalError(error);
50 // s.SetOffset(offset);
51 // s.SetGain(gain);
52 // Float_t loc[3],dr[3],sigma;
53 // s.GetPosition(loc,"sph");
54 // s.GetPositionErrors(dr,"sph");
55 // Float_t adc=s.GetSignal();
56 // Float_t sigma=s.GetSignalError();
57 //
58 // AliSignal q;    // In the example below a signal contains the
59 //                 // following data : timing, ADC and dE/dx
60 // q.SetName("TOF hit");
61 // q.SetPosition(pos,"car");
62 // q.SetPositionErrors(err,"car");
63 // signal=82.5; // e.g. signal time in ns
64 // error=2.01;
65 // offset=0.003;
66 // q.SetSignal(signal,1);
67 // q.SetSignalError(error,1);
68 // q.SetOffset(offset,1);
69 // signal=268.1; // e.g. ADC value of signal
70 // error=3.75;
71 // gain=120.78;
72 // q.SetSignal(signal,2);
73 // q.SetSignalError(error,2);
74 // q.SetGain(gain,2);
75 // signal=23.7; // e.g. corresponding dE/dx value
76 // error=0.48;
77 // offset=0.2;
78 // gain=150;
79 // q.SetSignal(signal,3);
80 // q.SetSignalError(error,3);
81 // q.SetOffset(offset,3);
82 // q.SetGain(gain,3);
83 //
84 //--- Author: Nick van Eijndhoven 23-jan-1999 UU-SAP Utrecht
85 //- Modified: NvE $Date$ UU-SAP Utrecht
86 ///////////////////////////////////////////////////////////////////////////
87
88 #include "AliSignal.h"
89 #include "Riostream.h"
90  
91 ClassImp(AliSignal) // Class implementation to enable ROOT I/O
92  
93 AliSignal::AliSignal() : TObject(),AliPosition(),AliAttrib()
94 {
95 // Creation of an AliSignal object and initialisation of parameters.
96 // Several signal values (with errors) can be stored in different slots.
97 // If needed, the storage for values (and errors) will be expanded automatically
98 // when entering values and/or errors.
99  fSignals=0;
100  fDsignals=0;
101  fWaveforms=0;
102  fName="Unspecified";
103 }
104 ///////////////////////////////////////////////////////////////////////////
105 AliSignal::~AliSignal()
106 {
107 // Destructor to delete dynamically allocated memory
108  if (fSignals)
109  {
110   delete fSignals;
111   fSignals=0;
112  }
113  if (fDsignals)
114  {
115   delete fDsignals;
116   fDsignals=0;
117  }
118  if (fWaveforms)
119  {
120   delete fWaveforms;
121   fWaveforms=0;
122  }
123 }
124 ///////////////////////////////////////////////////////////////////////////
125 AliSignal::AliSignal(AliSignal& s) : TObject(s),AliPosition(s),AliAttrib(s)
126 {
127 // Copy constructor
128  fSignals=0;
129  fDsignals=0;
130  fName=s.fName;
131  fWaveforms=0;
132
133  Int_t n=s.GetNvalues();
134  Double_t val;
135  for (Int_t i=1; i<=n; i++)
136  {
137   val=s.GetSignal(i);
138   SetSignal(val,i);
139  } 
140
141  n=s.GetNerrors();
142  for (Int_t j=1; j<=n; j++)
143  {
144   val=s.GetSignalError(j);
145   SetSignalError(val,j);
146  }
147
148  n=s.GetNwaveforms();
149  for (Int_t k=1; k<=n; k++)
150  {
151   TH1F* hist=s.GetWaveform(k);
152   if (hist) SetWaveform(hist,k); 
153  }
154 }
155 ///////////////////////////////////////////////////////////////////////////
156 void AliSignal::Reset(Int_t mode)
157 {
158 // Reset all signal and position values and errors to 0.
159 //
160 // mode = 0 Reset position and all signal values and their errors to 0.
161 //          The waveform histograms are reset, but the calibration
162 //          constants (i.e. gains and offsets) are kept.
163 //        1 Reset position and delete the signal and error storage arrays.
164 //          Also the waveform histograms, gains and offset arrays are deleted.
165 //
166 // The default when invoking Reset() corresponds to mode=0.
167 //
168 // The usage of mode=0 allows to re-use the allocated memory for new
169 // signal (and error) values. This behaviour is preferable (i.e. faster)
170 // in case the various signals always contain the same number of values
171 // and have the same calibration constants.
172 // The usage of mode=1 is slower, but allows a more efficient memory
173 // occupation (and smaller output file size) in case the different
174 // signals have a variable number of values.
175 //
176 // For more specific actions see ResetPosition(), ResetSignals(),
177 // DeleteSignals(), ResetGain(), ResetOffset() and DeleteCalibrations().
178 //
179
180  if (mode<0 || mode>1)
181  {
182   cout << " *AliSignal::Reset* Invalid argument mode = " << mode << endl;
183   cout << " Default mode=0 will be used." << endl;
184   mode=0;
185  }
186
187  ResetPosition();
188  if (!mode)
189  {
190   ResetSignals();
191  }
192  else
193  {
194   DeleteSignals();
195   DeleteCalibrations();
196  }
197 }
198 ///////////////////////////////////////////////////////////////////////////
199 void AliSignal::ResetSignals(Int_t mode)
200 {
201 // Reset various signal data according to user selection.
202 //
203 // mode = 0 Reset all signal values and their errors to 0.
204 //        1 Reset only signal values
205 //        2 Reset only signal errors
206 //
207 // The default when invoking ResetSignals() corresponds to mode=0.
208 //
209 // Irrespective of the mode, the waveform histograms are reset.
210
211  if (mode<0 || mode>2)
212  {
213   cout << " *AliSignal::ResetSignals* Invalid argument mode = " << mode << endl;
214   cout << " Default mode=0 will be used." << endl;
215   mode=0;
216  }
217
218  if (fSignals && (mode==0 || mode==1))
219  {
220   for (Int_t i=0; i<fSignals->GetSize(); i++)
221   {
222    fSignals->AddAt(0,i);
223   }
224  }
225
226  if (fDsignals && (mode==0 || mode==2))
227  {
228   for (Int_t j=0; j<fDsignals->GetSize(); j++)
229   {
230    fDsignals->AddAt(0,j);
231   }
232  }
233
234  ResetWaveform(0);
235 }
236 ///////////////////////////////////////////////////////////////////////////
237 void AliSignal::DeleteSignals(Int_t mode)
238 {
239 // Delete storage arrays of various signal data according to user selection.
240 //
241 // mode = 0 Delete arrays of both signal values and their errors.
242 //        1 Delete only signal values array
243 //        2 Delete only signal errors array
244 //
245 // The default when invoking DeleteSignals() corresponds to mode=0.
246 //
247 // Irrespective of the mode, the waveform histograms are deleted.
248
249  if (mode<0 || mode>2)
250  {
251   cout << " *AliSignal::DeleteSignals* Invalid argument mode = " << mode << endl;
252   cout << " Default mode=0 will be used." << endl;
253   mode=0;
254  }
255
256  if (fSignals && (mode==0 || mode==1))
257  {
258   delete fSignals;
259   fSignals=0;
260  }
261
262  if (fDsignals && (mode==0 || mode==2))
263  {
264   delete fDsignals;
265   fDsignals=0;
266  }
267
268  DeleteWaveform(0);
269 }
270 ///////////////////////////////////////////////////////////////////////////
271 void AliSignal::ResetPosition()
272 {
273 // Reset the position and corresponding errors to 0.
274  Double_t r[3]={0,0,0};
275  SetPosition(r,"sph");
276  SetErrors(r,"car");
277 }
278 ///////////////////////////////////////////////////////////////////////////
279 void AliSignal::SetSignal(Double_t sig,Int_t j)
280 {
281 // Store value in the j-th (default j=1) signal slot.
282 // Note : The first signal slot is at j=1.
283 // In case the value of the index j exceeds the maximum number of reserved
284 // slots for signal values, the number of reserved slots for the
285 // signal values is increased automatically.
286
287  if (!fSignals)
288  {
289   fSignals=new TArrayF(j);
290   ResetSignals(1);
291  }
292
293  Int_t size=fSignals->GetSize();
294
295  if (j>size)
296  {
297   fSignals->Set(j);
298  }
299
300  fSignals->AddAt(float(sig),j-1);
301 }
302 ///////////////////////////////////////////////////////////////////////////
303 void AliSignal::AddSignal(Double_t sig,Int_t j)
304 {
305 // Add value to the j-th (default j=1) signal slot.
306 // Note : The first signal slot is at j=1.
307 // In case the value of the index j exceeds the maximum number of reserved
308 // slots for signal values, the number of reserved slots for the
309 // signal values is increased automatically.
310
311  if (!fSignals)
312  {
313   fSignals=new TArrayF(j);
314   ResetSignals(1);
315  }
316
317  Int_t size=fSignals->GetSize();
318
319  if (j>size)
320  {
321   fSignals->Set(j);
322  }
323
324  Float_t sum=(fSignals->At(j-1))+sig;
325  fSignals->AddAt(sum,j-1);
326 }
327 ///////////////////////////////////////////////////////////////////////////
328 Float_t AliSignal::GetSignal(Int_t j,Int_t mode)
329 {
330 // Provide value of the j-th (default j=1) signal slot.
331 // Note : The first signal slot is at j=1.
332 // In case no signal is present or the argument j is invalid, 0 is returned.
333 // The parameter "mode" allows for automatic gain etc... correction of the signal.
334 //
335 // mode = 0 : Just the j-th signal is returned.
336 //        1 : The j-th signal is corrected for the gain, offset, dead flag etc...
337 //            In case the gain value was not set, gain=1 will be assumed.
338 //            In case the gain value was 0, a signal value of 0 is returned.
339 //            In case the offset value was not set, offset=0 will be assumed.
340 //            In case the j-th slot was marked dead, 0 is returned.
341 //
342 // The corrected signal (sigc) is determined as follows :
343 //
344 //              sigc=(signal/gain)-offset 
345 //
346 // The default is mode=0.
347
348  Float_t sig=0;
349  Float_t gain=1;
350  Float_t offset=0;
351  if (fSignals)
352  {
353   if (j>0 && j<=(fSignals->GetSize()))
354   {
355    sig=fSignals->At(j-1);
356
357    if (mode==0) return sig;
358
359    // Correct the signal for the gain, offset, dead flag etc...
360    if (GetDeadValue(j)) return 0;
361
362    if (GetGainFlag(j)) gain=GetGain(j);
363    if (GetOffsetFlag(j)) offset=GetOffset(j);
364
365    if (fabs(gain)>0.)
366    {
367     sig=(sig/gain)-offset;
368    }
369    else
370    {
371     sig=0;
372    }
373   }
374   else
375   {
376    cout << " *AliSignal::GetSignal* Index j = " << j << " invalid." << endl;
377   } 
378  }
379  return sig;
380 }
381 ///////////////////////////////////////////////////////////////////////////
382 void AliSignal::SetSignalError(Double_t dsig,Int_t j)
383 {
384 // Store error for the j-th (default j=1) signal slot.
385 // Note : The first signal slot is at j=1.
386 // In case the value of the index j exceeds the maximum number of reserved
387 // slots for signal error values, the number of reserved slots for the
388 // signal errors is increased automatically.
389
390  if (!fDsignals)
391  {
392   fDsignals=new TArrayF(j);
393   ResetSignals(2);
394  }
395
396  Int_t size=fDsignals->GetSize();
397
398  if (j>size)
399  {
400   fDsignals->Set(j);
401  }
402
403  fDsignals->AddAt(float(dsig),j-1);
404 }
405 ///////////////////////////////////////////////////////////////////////////
406 Float_t AliSignal::GetSignalError(Int_t j)
407 {
408 // Provide error of the j-th (default j=1) signal slot.
409 // Note : The first signal slot is at j=1.
410 // In case no signal is present or the argument j is invalid, 0 is returned.
411  Float_t err=0;
412  if (fDsignals)
413  {
414   if (j>0 && j<=(fDsignals->GetSize()))
415   {
416    err=fDsignals->At(j-1);
417   }
418   else
419   {
420    cout << " *AliSignal::GetSignalError* Index j = " << j << " invalid." << endl;
421   } 
422  }
423  return err;
424 }
425 ///////////////////////////////////////////////////////////////////////////
426 void AliSignal::Data(TString f,Int_t j)
427 {
428 // Provide signal information for the j-th slot within the coordinate frame f.
429 // The first slot is at j=1.
430 // In case j=0 (default) the data of all slots will be listed.
431
432  if (j<0) 
433  {
434   cout << " *AliSignal::Data* Invalid argument j = " << j << endl;
435   return;
436  }
437
438  cout << " *AliSignal::Data* Signal of kind : " << fName.Data() << endl;
439  cout << " Position";
440  Ali3Vector::Data(f);
441
442  Int_t nvalues=GetNvalues();
443  Int_t nerrors=GetNerrors();
444  Int_t n=nvalues;
445  if (nerrors>n) n=nerrors;
446
447  if (j==0)
448  {
449   for (Int_t i=1; i<=n; i++)
450   {
451    cout << "   Signal";
452    if (i<=nvalues) cout << " value : " << GetSignal(i);
453    if (i<=nerrors) cout << " error : " << GetSignalError(i);
454    AliAttrib::Data(i);
455    cout << endl;
456   }
457  }
458  else
459  {
460   if (j<=n)
461   {
462    cout << "   Signal";
463    if (j<=nvalues) cout << " value : " << GetSignal(j);
464    if (j<=nerrors) cout << " error : " << GetSignalError(j);
465    AliAttrib::Data(j);
466    cout << endl;
467   }
468  }
469
470 ///////////////////////////////////////////////////////////////////////////
471 void AliSignal::SetName(TString name)
472 {
473 // Set the name tag to indicate the kind of signal.
474  fName=name;
475 }
476 ///////////////////////////////////////////////////////////////////////////
477 TString AliSignal::GetName()
478 {
479 // Provide the name tag indicating the kind of signal.
480  return fName;
481 }
482 ///////////////////////////////////////////////////////////////////////////
483 Int_t AliSignal::GetNvalues()
484 {
485 // Provide the number of values for this signal.
486  Int_t n=0;
487  if (fSignals) n=fSignals->GetSize();
488  return n;
489 }
490 ///////////////////////////////////////////////////////////////////////////
491 Int_t AliSignal::GetNerrors()
492 {
493 // Provide the number specified errors on the values for this signal.
494  Int_t n=0;
495  if (fDsignals) n=fDsignals->GetSize();
496  return n;
497 }
498 ///////////////////////////////////////////////////////////////////////////
499 Int_t AliSignal::GetNwaveforms()
500 {
501 // Provide the number specified waveforms for this signal.
502  Int_t n=0;
503  if (fWaveforms) n=fWaveforms->GetSize();
504  return n;
505 }
506 ///////////////////////////////////////////////////////////////////////////
507 TH1F* AliSignal::GetWaveform(Int_t j)
508 {
509 // Provide pointer to the j-th waveform histogram.
510  TH1F* waveform=0;
511  if (j <= GetNwaveforms()) waveform=(TH1F*)fWaveforms->At(j-1);
512  return waveform;
513 }
514 ///////////////////////////////////////////////////////////////////////////
515 void AliSignal::SetWaveform(TH1F* waveform,Int_t j)
516 {
517 // Set the 1D waveform histogram corresponding to the j-th signal value.
518 //
519 // Notes :
520 //  The waveform of the first signal value is at j=1.
521 //  j=1 is the default value.
522 //
523 // In case the value of the index j exceeds the maximum number of reserved
524 // slots for the waveforms, the number of reserved slots for the waveforms
525 // is increased automatically.
526 //
527 // In case the histo pointer argument has the same value as the current waveform
528 // histogram pointer value, no action is taken since the user has already
529 // modified the actual histogram.
530 //
531 // In case the histo pointer argument is zero, the current waveform histogram
532 // is deleted and the pointer set to zero.
533 //
534 // In all other cases the current waveform histogram is deleted and a new
535 // copy of the input histogram is created which becomes the current waveform
536 // histogram.
537
538  if (!fWaveforms)
539  {
540   fWaveforms=new TObjArray(j);
541   fWaveforms->SetOwner();
542  }
543
544  if (j > fWaveforms->GetSize()) fWaveforms->Expand(j);
545
546  TH1F* hcur=(TH1F*)fWaveforms->At(j-1);
547  if (waveform != hcur)
548  {
549   if (hcur)
550   {
551    fWaveforms->Remove(hcur);
552    delete hcur;
553    hcur=0;
554   }
555   if (waveform)
556   {
557    hcur=new TH1F(*waveform);
558    fWaveforms->AddAt(hcur,j-1);
559   }
560  } 
561 }
562 ///////////////////////////////////////////////////////////////////////////
563 void AliSignal::ResetWaveform(Int_t j)
564 {
565 // Reset the waveform of the j-th (default j=1) signal value.
566 // This memberfunction invokes TH1F::Reset() for the corresponding waveform(s).
567 // To actually delete the histograms from memory, use DeleteWaveform().
568 // Notes : The first signal value is at j=1.
569 //         j=0 ==> All waveforms will be reset.
570  
571  if (!fWaveforms) return;
572
573  Int_t size=fWaveforms->GetSize();
574
575  if ((j>=0) && (j<=size))
576  {
577   if (j)
578   {
579    TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
580    if (hwave) hwave->Reset();
581   }
582   else
583   {
584    for (Int_t i=0; i<size; i++)
585    {
586     TH1F* hwave=(TH1F*)fWaveforms->At(i);
587     if (hwave) hwave->Reset();
588    }
589   }
590  }
591  else
592  {
593   cout << " *AliSignal::ResetWaveform* Index j = " << j << " invalid." << endl;
594   return;
595  }
596 }
597 ///////////////////////////////////////////////////////////////////////////
598 void AliSignal::DeleteWaveform(Int_t j)
599 {
600 // Delete the waveform of the j-th (default j=1) signal value.
601 // Notes : The first signal value is at j=1.
602 //         j=0 ==> All waveforms will be deleted.
603  
604  if (!fWaveforms) return;
605
606  Int_t size=fWaveforms->GetSize();
607
608  if ((j>=0) && (j<=size))
609  {
610   if (j)
611   {
612    TH1F* hwave=(TH1F*)fWaveforms->At(j-1);
613    if (hwave)
614    {
615     fWaveforms->Remove(hwave);
616     delete hwave;
617    }
618   }
619   else
620   {
621    delete fWaveforms;
622    fWaveforms=0;
623   }
624  }
625  else
626  {
627   cout << " *AliSignal::DeleteWaveform* Index j = " << j << " invalid." << endl;
628   return;
629  }
630 }
631 ///////////////////////////////////////////////////////////////////////////
632 AliSignal* AliSignal::MakeCopy(AliSignal& s)
633 {
634 // Make a deep copy of the input object and provide the pointer to the copy.
635 // This memberfunction enables automatic creation of new objects of the
636 // correct type depending on the argument type, a feature which may be very useful
637 // for containers when adding objects in case the container owns the objects.
638 // This feature allows e.g. AliTrack to store either AliSignal objects or
639 // objects derived from AliSignal via the AddSignal memberfunction, provided
640 // these derived classes also have a proper MakeCopy memberfunction. 
641
642  AliSignal* sig=new AliSignal(s);
643  return sig;
644 }
645 ///////////////////////////////////////////////////////////////////////////