3acc80d92b2a29f413e7df9aab46b3c22f0234f3
[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 // Handling of ALICE (extrapolated) 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 // s.SetPosition(pos,"car");
45 // s.SetPositionErrors(err,"car");
46 // s.SetSignal(signal);
47 // s.SetSignalError(error);
48 // Float_t loc[3],dr[3],sigma;
49 // s.GetPosition(loc,"sph");
50 // s.GetPositionErrors(dr,"sph");
51 // Float_t adc=s.GetSignal();
52 // Float_t sigma=s.GetSignalError();
53 //
54 // AliSignal q(3); // q can store 3 signal values with their errors
55 //                 // In the example below a signal contains the
56 //                 // following data : timing, ADC and dE/dx
57 // q.SetName("TOF hit");
58 // q.SetPosition(pos,"car");
59 // q.SetPositionErrors(err,"car");
60 // signal=82.5; // e.g. signal time in ns
61 // error=2.01;
62 // q.SetSignal(signal,1);
63 // q.SetSignalError(error,1);
64 // signal=268.1; // e.g. ADC value of signal
65 // error=3.75;
66 // q.SetSignal(signal,2);
67 // q.SetSignalError(error,2);
68 // signal=23.7; // e.g. corresponding dE/dx value
69 // error=0.48;
70 // q.SetSignal(signal,3);
71 // q.SetSignalError(error,3);
72 //
73 //--- Author: Nick van Eijndhoven 23-jan-1999 UU-SAP Utrecht
74 //- Modified: NvE $Date$ UU-SAP Utrecht
75 ///////////////////////////////////////////////////////////////////////////
76
77 #include "AliSignal.h"
78  
79 ClassImp(AliSignal) // Class implementation to enable ROOT I/O
80  
81 AliSignal::AliSignal(Int_t n)
82 {
83 // Creation of an AliSignal object and initialisation of parameters.
84 // A total of n (default n=1) values (with errors) can be stored.
85  fNvalues=n;
86  fSignal=0;
87  fDsignal=0;
88  fName=" ";
89 }
90 ///////////////////////////////////////////////////////////////////////////
91 AliSignal::~AliSignal()
92 {
93 // Destructor to delete dynamically allocated memory
94  if (fSignal)
95  {
96   delete fSignal;
97   fSignal=0;
98  }
99  if (fDsignal)
100  {
101   delete fDsignal;
102   fDsignal=0;
103  }
104 }
105 ///////////////////////////////////////////////////////////////////////////
106 AliSignal::AliSignal(AliSignal& s)
107 {
108 // Copy constructor
109  fNvalues=s.GetNvalues();
110  fSignal=0;
111  fDsignal=0;
112  fName=s.GetName();
113  
114  SetPosition((Ali3Vector&)s);
115
116  Double_t sig,err;
117  for (Int_t i=1; i<=fNvalues; i++)
118  {
119   sig=s.GetSignal(i);
120   err=s.GetSignalError(i);
121   SetSignal(sig,i);
122   SetSignalError(err,i);
123  } 
124 }
125 ///////////////////////////////////////////////////////////////////////////
126 void AliSignal::Reset()
127 {
128 // Reset all signal and position values and errors to 0.
129 // The data arrays are also created if not already existing.
130
131  if (!fSignal) fSignal=new TArrayF(fNvalues);
132  if (!fDsignal) fDsignal=new TArrayF(fNvalues);
133
134  Double_t r[3]={0,0,0};
135  SetPosition(r,"sph");
136  SetErrors(r,"car");
137  for (Int_t i=0; i<fSignal->GetSize(); i++)
138  {
139   fSignal->AddAt(0,i);
140   fDsignal->AddAt(0,i);
141  }
142 }
143 ///////////////////////////////////////////////////////////////////////////
144 void AliSignal::ResetSignals()
145 {
146 // Reset all signal values and errors to 0.
147 // The data arrays are also created if not already existing.
148
149  if (!fSignal) fSignal=new TArrayF(fNvalues);
150  if (!fDsignal) fDsignal=new TArrayF(fNvalues);
151
152  for (Int_t i=0; i<fSignal->GetSize(); i++)
153  {
154   fSignal->AddAt(0,i);
155   fDsignal->AddAt(0,i);
156  }
157 }
158 ///////////////////////////////////////////////////////////////////////////
159 void AliSignal::ResetPosition()
160 {
161 // Reset position and errors to 0.
162  Double_t r[3]={0,0,0};
163  SetPosition(r,"sph");
164  SetErrors(r,"car");
165 }
166 ///////////////////////////////////////////////////////////////////////////
167 void AliSignal::SetSignal(Double_t sig,Int_t j)
168 {
169 // Store j-th (default j=1) signal value.
170 // Note : The first signal value is at j=1.
171
172  if (!fSignal) ResetSignals();
173
174  Int_t size=fSignal->GetSize();
175  if (j<=size)
176  {
177   fSignal->AddAt(float(sig),j-1);
178  }
179  else
180  {
181   cout << "*AliSignal::SetSignal* Index mismatch j : " << j
182        << " size : " << size << endl;
183  }
184 }
185 ///////////////////////////////////////////////////////////////////////////
186 void AliSignal::AddSignal(Double_t sig,Int_t j)
187 {
188 // Add value to j-th (default j=1) signal value.
189 // Note : The first signal value is at j=1.
190
191  if (!fSignal) ResetSignals();
192
193  Int_t size=fSignal->GetSize();
194  if (j<=size)
195  {
196   Float_t sum=(fSignal->At(j-1))+sig;
197   fSignal->AddAt(sum,j-1);
198  }
199  else
200  {
201   cout << "*AliSignal::AddSignal* Index mismatch j : " << j
202        << " size : " << size << endl;
203  }
204 }
205 ///////////////////////////////////////////////////////////////////////////
206 Float_t AliSignal::GetSignal(Int_t j)
207 {
208 // Provide j-th (default j=1) signal value.
209 // Note : The first signal value is at j=1.
210  if (fSignal)
211  {
212   return fSignal->At(j-1);
213  }
214  else
215  {
216   return 0;
217  }
218 }
219 ///////////////////////////////////////////////////////////////////////////
220 void AliSignal::SetSignalError(Double_t dsig,Int_t j)
221 {
222 // Store error on j-th (default j=1) signal value.
223 // Note : The error on the first signal value is at j=1.
224
225  if (!fDsignal) ResetSignals();
226
227  Int_t size=fDsignal->GetSize();
228  if (j<=size)
229  {
230   fDsignal->AddAt(float(dsig),j-1);
231  }
232  else
233  {
234   cout << "*AliSignal::SetSignalError* Index mismatch j : " << j
235        << " size : " << size << endl;
236  }
237 }
238 ///////////////////////////////////////////////////////////////////////////
239 Float_t AliSignal::GetSignalError(Int_t j)
240 {
241 // Provide error on the j-th (default j=1) signal value.
242 // Note : The error on the first signal value is at j=1.
243  if (fDsignal)
244  {
245   return fDsignal->At(j-1);
246  }
247  else
248  {
249   return 0;
250  }
251 }
252 ///////////////////////////////////////////////////////////////////////////
253 void AliSignal::Info(TString f)
254 {
255 // Provide signal information within the coordinate frame f
256  cout << " *AliSignal::Info* For signal of kind : " << fName << endl;
257  cout << " Position";
258  Ali3Vector::Info(f); 
259  
260  if (fSignal && fDsignal)
261  {
262   for (Int_t i=0; i<fSignal->GetSize(); i++)
263   {
264    cout << "   Signal value : " << fSignal->At(i)
265         << " error : " << fDsignal->At(i) << endl;
266   }
267  }
268
269 ///////////////////////////////////////////////////////////////////////////
270 void AliSignal::SetName(TString name)
271 {
272 // Set the name tag to indicate the kind of signal.
273  fName=name;
274 }
275 ///////////////////////////////////////////////////////////////////////////
276 TString AliSignal::GetName()
277 {
278 // Provide the name tag indicating the kind of signal.
279  return fName;
280 }
281 ///////////////////////////////////////////////////////////////////////////
282 Int_t AliSignal::GetNvalues()
283 {
284 // Provide the number of values for this signal.
285  return fNvalues;
286 }
287 ///////////////////////////////////////////////////////////////////////////