Possibility to not write syswatch info to file (default)
[u/mrichter/AliRoot.git] / STEER / ESD / AliESDCaloTrigger.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 /*
17  
18
19  
20
21 Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
22 */
23
24 #include "AliESDCaloTrigger.h"
25 #include "AliLog.h"
26
27 #include "TArrayI.h"
28 #include "Riostream.h"
29 #include <cstdlib>
30
31 ClassImp(AliESDCaloTrigger)
32
33 //_______________
34 AliESDCaloTrigger::AliESDCaloTrigger() : AliVCaloTrigger(),
35 fNEntries(0),
36 fCurrent(-1),
37 fColumn(0x0),
38 fRow(0x0),
39 fAmplitude(0x0),
40 fTime(0x0),
41 fNL0Times(0x0),
42 fL0Times(new TArrayI()),
43 fL1TimeSum(0x0),
44 fTriggerBits(0x0),
45 fL1Threshold(),
46 fL1V0(),
47 fL1FrameMask(0)
48 {
49         //
50         for (int i = 0; i < 4; i++) fL1Threshold[i] = 0;
51         fL1V0[0] = fL1V0[1] = 0;        
52 }
53
54 //_______________
55 AliESDCaloTrigger::AliESDCaloTrigger(const AliESDCaloTrigger& src) : AliVCaloTrigger(src),
56 fNEntries(0),
57 fCurrent(-1),
58 fColumn(0x0),
59 fRow(0x0),
60 fAmplitude(0x0),
61 fTime(0x0),
62 fNL0Times(0x0),
63 fL0Times(new TArrayI()),
64 fL1TimeSum(0x0),
65 fTriggerBits(0x0),
66 fL1Threshold(),
67 fL1V0(),
68 fL1FrameMask(0)
69 {
70         //
71         src.Copy(*this);
72 }
73
74 //_______________
75 AliESDCaloTrigger::~AliESDCaloTrigger()
76 {
77         //
78         if (fNEntries) DeAllocate();
79         
80         delete fL0Times; fL0Times = 0x0;
81 }
82
83 //_______________
84 void AliESDCaloTrigger::DeAllocate()
85 {
86         //
87         delete [] fColumn;      fColumn    = 0x0;
88         delete [] fRow;         fRow       = 0x0;     
89         delete [] fAmplitude;   fAmplitude = 0x0;
90         delete [] fTime;        fTime      = 0x0;   
91         delete [] fNL0Times;    fNL0Times  = 0x0;
92         delete [] fL1TimeSum;   fL1TimeSum = 0x0;
93         delete [] fTriggerBits; fTriggerBits   = 0x0;
94
95         fNEntries =  0;
96         fCurrent  = -1;
97
98         fL0Times->Reset();
99 }
100
101 //_______________
102 AliESDCaloTrigger& AliESDCaloTrigger::operator=(const AliESDCaloTrigger& src)
103 {
104         //
105         if (this != &src) src.Copy(*this);
106         
107         return *this;
108 }
109
110 //_______________
111 void AliESDCaloTrigger::Copy(TObject &obj) const 
112 {       
113         //
114         AliVCaloTrigger::Copy(obj);
115         
116         AliESDCaloTrigger& dest = static_cast<AliESDCaloTrigger&>(obj);
117
118         if (dest.fNEntries) dest.DeAllocate();
119         
120         dest.Allocate(fNEntries);
121         
122         for (Int_t i = 0; i < fNEntries; i++)
123         {
124                 Int_t times[10];
125                 for (Int_t j = 0; j < 10; j++) times[j] = fL0Times->At(10 * i + j);
126           
127                 dest.Add(fColumn[i], fRow[i], fAmplitude[i], fTime[i], times, fNL0Times[i], fL1TimeSum[i], fTriggerBits[i]);
128         }       
129
130         for (int i = 0; i < 4; i++) dest.SetL1Threshold(i, fL1Threshold[i]);
131         
132         dest.SetL1V0(fL1V0);
133         dest.SetL1FrameMask(fL1FrameMask);
134 }
135
136 //_______________
137 void AliESDCaloTrigger::Allocate(Int_t size)
138 {
139         //
140         if (!size) return;
141         
142         fNEntries = size;
143         
144         fColumn      = new   Int_t[fNEntries];
145         fRow         = new   Int_t[fNEntries];
146         fAmplitude   = new Float_t[fNEntries];
147         fTime        = new Float_t[fNEntries];
148         fNL0Times    = new   Int_t[fNEntries];
149         fL1TimeSum   = new   Int_t[fNEntries];
150         fTriggerBits = new   Int_t[fNEntries];
151
152         for (Int_t i = 0; i < fNEntries; i++) 
153         {
154           fColumn[i]      = 0;
155           fRow[i]         = 0;
156           fAmplitude[i]   = 0;
157           fTime[i]        = 0;
158           fNL0Times[i]    = 0;
159           fL1TimeSum[i]   = 0;
160           fTriggerBits[i] = 0;
161         }
162         
163         fL0Times->Set(fNEntries * 10);
164 }
165
166 //_______________
167 Bool_t AliESDCaloTrigger::Add(Int_t col, Int_t row, Float_t amp, Float_t time, Int_t trgtimes[], Int_t ntrgtimes, Int_t trgts, Int_t trgbits)
168 {
169         //
170         fCurrent++;
171         
172              fColumn[fCurrent] = col;
173                 fRow[fCurrent] = row;
174           fAmplitude[fCurrent] = amp;
175                fTime[fCurrent] = time;
176            fNL0Times[fCurrent] = ntrgtimes;
177           fL1TimeSum[fCurrent] = trgts; 
178         fTriggerBits[fCurrent] = trgbits;
179         
180         if (ntrgtimes > 9) 
181         {
182                 AliError("Should not have more than 10 L0 times");
183                 return kFALSE;
184         }
185         
186         for (Int_t i = 0; i < fNL0Times[fCurrent]; i++) fL0Times->AddAt(trgtimes[i], 10 * fCurrent + i);
187
188         return kTRUE;
189 }
190
191 //_______________
192 Bool_t AliESDCaloTrigger::Next()
193 {
194         //
195         if (fCurrent >= fNEntries - 1 || !fNEntries) return kFALSE;
196         
197         fCurrent++;
198         
199         return kTRUE;
200 }
201
202 //_______________
203 void AliESDCaloTrigger::GetPosition(Int_t& col, Int_t& row) const
204 {
205         //
206         if (fCurrent == -1) return;
207         
208         col = fColumn?fColumn[fCurrent]:0;
209         row =    fRow?fRow[fCurrent]:0;
210 }
211
212 //_______________
213 void AliESDCaloTrigger::GetAmplitude(Float_t& amp) const
214 {
215         //
216         if (fCurrent == -1) return;
217
218         amp = fAmplitude?fAmplitude[fCurrent]:0;
219 }
220
221 //_______________
222 void AliESDCaloTrigger::GetTime(Float_t& time) const
223 {
224         //
225         if (fCurrent == -1) return;
226
227         time = fTime?fTime[fCurrent]:0;
228 }
229
230 //_______________
231 void AliESDCaloTrigger::GetL1TimeSum(Int_t& amp) const
232 {
233         //      
234         if (fCurrent == -1) return;
235
236         amp = fL1TimeSum?fL1TimeSum[fCurrent]:0;
237 }
238
239 //_______________
240 void AliESDCaloTrigger::GetNL0Times(Int_t& ntimes) const
241 {
242         //
243         if (fCurrent == -1) return;
244
245         ntimes = fNL0Times?fNL0Times[fCurrent]:0;
246 }
247
248 //_______________
249 void AliESDCaloTrigger::GetTriggerBits(Int_t& bits) const
250 {
251         //
252         if (fCurrent == -1) return;
253
254         bits = fTriggerBits?fTriggerBits[fCurrent]:0;
255 }
256
257 //_______________
258 void AliESDCaloTrigger::GetL0Times(Int_t times[]) const
259 {
260         //
261         if (fCurrent == -1) return;
262         
263         if (fNL0Times && fL0Times) {
264           for (Int_t i = 0; i < fNL0Times[fCurrent]; i++) times[i] = fL0Times->At(10 * fCurrent + i);
265         }
266 }
267
268 //_______________
269 void AliESDCaloTrigger::Print(const Option_t* /*opt*/) const
270 {
271         //
272         if (fCurrent == -1) return;
273         if (!fColumn) return;
274         if (!fRow) return;
275         if (!fAmplitude) return;
276         if (!fTime) return;
277         if (!fNL0Times) return;
278         if (!fL0Times) return;
279         if (!fL1TimeSum) return;
280         if (!fTriggerBits) return;
281
282         printf("============\n");
283         printf("--L0:\n");
284         printf("\tPOSITION (X: %2d Y: %2d) / FITTED F-ALTRO (AMP: %4f TIME: %3f)\n", 
285                    fColumn[fCurrent], fRow[fCurrent], fAmplitude[fCurrent], fTime[fCurrent]);
286         printf("\t%d L0 TIMES (", fNL0Times[fCurrent]); 
287         for (Int_t i = 0; i < fNL0Times[fCurrent]; i++) printf("%2d ",fL0Times->At(10 * fCurrent + i));
288         printf(")\n");
289         printf("--L1:\n");
290         printf("\tTIME SUM: %4d\n", fL1TimeSum[fCurrent]);
291         printf("\tHIGH THRESHOLDS (GAMMA: %4d, JET: %4d)\n", fL1Threshold[0], fL1Threshold[1]);
292         printf("\tLOW THRESHOLDS (GAMMA: %4d, JET: %4d)\n", fL1Threshold[2], fL1Threshold[3]);
293         printf("--TRIGGER BITS: 0x%x\n", fTriggerBits[fCurrent]);
294 }