clear debug cluster array after each tracklet fill
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALTriggerTRU.cxx
CommitLineData
916f1e76 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
21Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
22*/
23
24
25#include "AliEMCALTriggerTRU.h"
26#include "AliEMCALTriggerPatch.h"
fff39dd1 27#include "AliEMCALTriggerTRUDCSConfig.h"
916f1e76 28#include "AliLog.h"
29
916f1e76 30#include <TClonesArray.h>
31#include <TSystem.h>
32#include <Riostream.h>
33
34namespace
35{
fff39dd1 36 const Int_t kTimeBins = 16; // number of sampling bins of the FastOR signal
916f1e76 37 const Int_t kTimeWindowSize = 4; //
38 const Int_t kNup = 2; //
39 const Int_t kNdown = 1; //
40}
41
42ClassImp(AliEMCALTriggerTRU)
43
44//________________
fff39dd1 45AliEMCALTriggerTRU::AliEMCALTriggerTRU() : AliEMCALTriggerBoard()
46,fDCSConfig(0x0)
916f1e76 47{
48 //
49 for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
50}
51
52//________________
fff39dd1 53AliEMCALTriggerTRU::AliEMCALTriggerTRU(AliEMCALTriggerTRUDCSConfig* dcsConf, const TVector2& rSize, Int_t mapType) :
54AliEMCALTriggerBoard(rSize)
55,fDCSConfig(dcsConf)
916f1e76 56{
57 //
58 for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
59
60 // FIXME: use of class AliEMCALTriggerParam to get size
61 TVector2 size;
62
63 size.Set( 1. , 1. );
64 SetSubRegionSize( size ); // 1 by 1 FOR
65
66 size.Set( 2. , 2. );
67 SetPatchSize( size ); // 2 by 2 subregions
68
69 for (Int_t ietam=0;ietam<24;ietam++)
70 {
71 for (Int_t iphim=0;iphim<4;iphim++)
72 {
73 // idx: 0..95 since iphim: 0..11 ietam: 0..23
74 Int_t idx = ( !mapType ) ? ( 3 - iphim ) + ietam * 4 : iphim + (23 - ietam) * 4;
75
76 // Build a matrix used to get TRU digit id (ADC channel) from (eta,phi)|SM
77 fMap[ietam][iphim] = idx; // [0..11][0..3] namely [eta][phi] in SM
78 }
79 }
80}
81
82//________________
83AliEMCALTriggerTRU::~AliEMCALTriggerTRU()
84{
85 // delete TRU digits only used as transient containers
86 // to compute FastOR from energy deposit
916f1e76 87}
88
89//________________
916f1e76 90void AliEMCALTriggerTRU::ShowFastOR(Int_t iTimeWindow, Int_t iChannel)
91{
92 //
93 Int_t iChanF, iChanL;
94
95 if (iChannel != -1) iChanF = iChanL = iChannel;
96 else
97 {
98 iChanF = 0;
99 iChanL = 96;
100 }
101
102 for (Int_t i=iChanF;i<iChanL+1;i++)
103 {
104 printf("\tChannel: %2d - ",i);
105 for (Int_t j=0;j<60;j++)
106 {
107 if (j == iTimeWindow)
108 printf(" | %4d",fADC[i][j]);
109 else if (j == iTimeWindow+kTimeWindowSize-1)
110 printf(" %4d |",fADC[i][j]);
111 else
112 printf(" %4d",fADC[i][j]);
113 }
114
115 printf("\n");
116 }
117}
118
119//________________
fff39dd1 120Int_t AliEMCALTriggerTRU::L0()
916f1e76 121{
122 // Mimick the TRU L0 'virtual' since not yet released algo
123
124 // L0 issuing condition is: (2 up & 1 down) AND (time sum > thres)
125 // fill a matrix to support sliding window
126 // compute the time sum for all the FastOR of a given TRU
127 // and then move the space window
fff39dd1 128
129 AliDebug(1,"=== Running TRU L0 algorithm ===");
8476b1c8 130 const Int_t xsize = Int_t(fRegionSize->X());
8b07b672 131 const Int_t ysize = Int_t(fRegionSize->Y());
132 const Int_t zsize = kNup+kNdown;
133
f4e2cc1e 134 Int_t ***buffer = new Int_t**[xsize];
135 for (Int_t x = 0; x < xsize; x++)
136 {
137 buffer[x] = new Int_t*[ysize];
138
139 for (Int_t y = 0; y < ysize; y++)
140 {
141 buffer[x][y] = new Int_t[zsize];
142 }
143 }
916f1e76 144
fff39dd1 145 for (Int_t i=0; i<fRegionSize->X(); i++) for (Int_t j=0; j<fRegionSize->Y(); j++)
146 for (Int_t k=0; k<kNup+kNdown; k++) buffer[i][j][k] = 0;
147
148 // Time sliding window algorithm
916f1e76 149 for (Int_t i=0; i<=(kTimeBins-kTimeWindowSize); i++)
150 {
fff39dd1 151 AliDebug(1,Form("----------- Time window: %d\n",i));
152
153 for (Int_t j=0; j<fRegionSize->X(); j++)
916f1e76 154 {
155 for (Int_t k=0; k<fRegionSize->Y(); k++)
156 {
157 for (Int_t l=i; l<i+kTimeWindowSize; l++)
158 {
fff39dd1 159// printf("fRegion[%2d][%2d]: %d += fADC[%2d][%2d]: %d\n",j,k,fRegion[j][k],fMap[j][k],l,fADC[fMap[j][k]][l]);
916f1e76 160 // [eta][phi][time]
fff39dd1 161 fRegion[j][k] += fADC[fMap[j][k]][l];
916f1e76 162 }
163
fff39dd1 164 buffer[j][k][i%(kNup + kNdown)] = fRegion[j][k];
916f1e76 165
fff39dd1 166 if ( i > kNup + kNdown - 1 )
167 {
168 for (Int_t v = 0; v < kNup + kNdown - 1; v++) buffer[j][k][v] = buffer[j][k][v+1];
169
170 buffer[j][k][kNup + kNdown - 1] = fRegion[j][k];
171 }
172 else
173 {
174 buffer[j][k][i] = fRegion[j][k];
175 }
916f1e76 176
fff39dd1 177/*
178 for (Int_t v = 0; v<kNup + kNdown; v++)
179 printf("buffer[%2d][%2d][%2d]: %d\n",j,k,v,buffer[j][k][v]);
180*/
916f1e76 181
fff39dd1 182// if (kTimeWindowSize > 4) fRegion[j][k] = fRegion[j][k] >> 1; // truncate time sum to fit 14b
916f1e76 183 }
184 }
185
fff39dd1 186 // Don't start to evaluate space sum if a peak can't be findable
187 if (i < kNup + kNdown - 1)
188 {
189 ZeroRegion();
190 continue;
191 }
916f1e76 192
f4e2cc1e 193 Int_t **peaks = new Int_t*[xsize];
194 for (Int_t x = 0; x < xsize; x++)
195 {
196 peaks[x] = new Int_t[ysize];
197 }
916f1e76 198
fff39dd1 199 for (Int_t j=0; j<fRegionSize->X(); j++) for (Int_t k=0; k<fRegionSize->Y(); k++) peaks[j][k] = 0;
200
201 Int_t nPeaks = 0;
916f1e76 202
203 for (Int_t j=0; j<fRegionSize->X(); j++)
204 {
205 for (Int_t k=0; k<fRegionSize->Y(); k++)
206 {
fff39dd1 207 Int_t foundU = 0;
208
209 Int_t foundD = 0;
210
211 for (Int_t l= 1;l<kNup ;l++) foundU = ( buffer[j][k][l]> buffer[j][k][l-1] && buffer[j][k][l-1] ) ? 1 : 0;
212
213 for (Int_t l=kNup;l<kNup+kNdown;l++) foundD = ( buffer[j][k][l]<=buffer[j][k][l-1] && buffer[j][k][l ] ) ? 1 : 0;
214
215 if ( foundU && foundD )
916f1e76 216 {
fff39dd1 217 peaks[j][k] = 1;
218 nPeaks++;
916f1e76 219 }
916f1e76 220 }
221 }
fff39dd1 222
223/*
224 for (Int_t j=0; j<fRegionSize->X(); j++)
225 {
226 for (Int_t k=0; k<fRegionSize->Y(); k++)
227 {
228 printf("peaks[%2d][%2d]: %d\n",j,k,peaks[j][k]);
229 }
230 }
231*/
232 if ( !nPeaks )
233 {
234 ZeroRegion();
235 continue;
236 }
916f1e76 237
238 // Threshold
239 // FIXME: for now consider just one threshold for all patches, should consider one per patch?
240 // ANSWE: both solutions will be implemented in the TRU
241 // return the list of patches above threshold
fff39dd1 242 // Theshold checked out from OCDB
916f1e76 243
fff39dd1 244 SlidingWindow( kGamma, fDCSConfig->GetGTHRL0() );
916f1e76 245
246// for(Int_t j=0; j<fRegionSize->X(); j++)
247// for (Int_t k=0; k<fRegionSize->Y(); k++) fRegion[j][k] = fRegion[j][k]>>2; // go to 12b before shipping to STU
248
249 Int_t nP = 0;
250
251 for (Int_t j=0; j<fPatches->GetEntriesFast(); j++)
252 {
253 AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)fPatches->At( j );
254
255 if ( AliDebugLevel() ) p->Print("");
256
fff39dd1 257 TVector2 v; p->Position(v);
916f1e76 258
da509d54 259 Int_t sizeX = (Int_t)(fPatchSize->X() * fSubRegionSize->X());
fff39dd1 260
da509d54 261 Int_t sizeY = (Int_t)(fPatchSize->Y() * fSubRegionSize->Y());
916f1e76 262
263 const Int_t psize = sizeX * sizeY; // Number of FastOR in the patch
264
fff39dd1 265 Int_t* idx = new Int_t[psize];
916f1e76 266
267 for (Int_t xx=0;xx<sizeX;xx++)
268 {
269 for (Int_t yy=0;yy<sizeY;yy++)
270 {
fff39dd1 271 Int_t index = xx*sizeY+yy;
916f1e76 272
fff39dd1 273 idx[index] = fMap[int(v.X()*fSubRegionSize->X())+xx][int(v.Y()*fSubRegionSize->Y())+yy]; // Get current patch FastOR ADC channels
916f1e76 274
fff39dd1 275 if (peaks[int(v.X()*fSubRegionSize->X())+xx][int(v.Y()*fSubRegionSize->Y())+yy]) nP++;
276
277 if ( AliDebugLevel() ) ShowFastOR(i,idx[index]);
916f1e76 278 }
279 }
916f1e76 280
fff39dd1 281 if ( nP )
916f1e76 282 {
fff39dd1 283// cout << "break patch loop" << endl;
284 break;
916f1e76 285 }
286 }
287
288 if ( !nP )
289 fPatches->Delete();
290 else
291 {
fff39dd1 292// cout << "break time loop" << endl;
916f1e76 293 break; // Stop the algo when at least one patch is found ( thres & max )
294 }
fff39dd1 295
f4e2cc1e 296 ZeroRegion(); // Clear fRegion for this time window before computing the next one
297
298 //Delete, avoid leak
299 for (Int_t x = 0; x < xsize; x++)
300 {
301 delete [] peaks[x];
302 }
303 delete [] peaks;
304
916f1e76 305 }
306
fff39dd1 307// cout << "Nof patches: " << fPatches->GetEntriesFast() << endl;
f4e2cc1e 308 //Delete, avoid leak
309 for (Int_t x = 0; x < xsize; x++)
310 {
311 for (Int_t y = 0; y < ysize; y++)
312 {
313 delete [] buffer[x][y];
314 }
315 delete [] buffer[x];
316 }
317 delete [] buffer;
8b07b672 318
916f1e76 319 return fPatches->GetEntriesFast();
320}
321
916f1e76 322//________________
323void AliEMCALTriggerTRU::SetADC( Int_t channel, Int_t bin, Int_t sig )
324{
325 //
326 if (channel>95) AliError("TRU has 96 ADC channels only!");
327 fADC[channel][bin] = sig;
328}
329
330//________________
916f1e76 331void AliEMCALTriggerTRU::SaveRegionADC(Int_t iTRU, Int_t iEvent)
332{
333 // O for STU Hw
334 //
335 gSystem->Exec(Form("mkdir -p Event%d",iEvent));
336
337 ofstream outfile(Form("Event%d/data_TRU%d.txt",iEvent,iTRU),ios_base::trunc);
338
339 for (Int_t i=0;i<96;i++)
340 {
341 Int_t ietam = 23 - i/4;
342
343 Int_t iphim = 3 - i%4;
344
345 outfile << fRegion[ietam][iphim] << endl;
346 }
347
348 outfile.close();
349}
350
916f1e76 351//________________
352void AliEMCALTriggerTRU::Reset()
353{
354 //
355 fPatches->Delete();
356
357 ZeroRegion();
358
359 for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
360}
361