Correction on new Trigger commit, some casting from float to integer and some arrays...
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALTriggerSTU.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 "AliEMCALTriggerSTU.h"
25 #include "AliCDBManager.h"
26 #include "AliCDBEntry.h"
27 #include "AliEMCALCalibData.h"
28 #include "AliVZEROCalibData.h"
29 #include "AliVZEROdigit.h"
30 #include "AliEMCALTriggerPatch.h"
31 #include "AliESDVZERO.h"
32 #include "AliLog.h"
33
34 #include <TClonesArray.h>
35 #include <TSystem.h>
36 #include <TH2F.h>
37 #include <TFile.h>
38 #include <TTree.h>
39
40 #include <fstream>
41 #include <Riostream.h>
42
43 ClassImp(AliEMCALTriggerSTU)
44
45 //_______________
46 AliEMCALTriggerSTU::AliEMCALTriggerSTU() : AliEMCALTriggerBoard()
47 {
48         //
49         fV0M[0] = fV0M[1] = 0;
50 }
51
52 //_______________
53 AliEMCALTriggerSTU::AliEMCALTriggerSTU(AliEMCALCalibData *calibData, const TVector2& RS) : 
54 AliEMCALTriggerBoard(calibData, RS)
55 {
56         //
57         fV0M[0] = fV0M[1] = 0;
58 }
59
60 //_______________
61 AliEMCALTriggerSTU::~AliEMCALTriggerSTU()
62 {
63         //
64 }
65
66 //_______________
67 void AliEMCALTriggerSTU::BuildMap( Int_t iTRU, Int_t** M, const TVector2* rSize )
68 {
69         //
70         if ( iTRU == 31 ) iTRU = 35;
71         
72         Int_t i2y = iTRU / 3 / 2;
73         
74         if ( ( iTRU / 3 ) % 2 ) // odd (z<0) C side
75         {
76                 Int_t i1y = 2 - ( iTRU - int( iTRU / 3 ) * 3 ); // 0 1 2 w/ increasing phi
77
78                 for (Int_t i=0; i<rSize->X(); i++) 
79                         for (Int_t j=0; j<rSize->Y(); j++) fMap[24+i][j + i1y * 4 + i2y * 12] = M[i][j];
80         }
81         else                   // A side
82         {
83                 Int_t i1y =       iTRU - int( iTRU / 3 ) * 3;
84                 
85                 for (Int_t i=0; i<rSize->X(); i++)
86                         for (Int_t j=0; j<rSize->Y(); j++) fMap[   i][j + i1y * 4 + i2y * 12] = M[i][j];
87         }       
88 }
89
90 //_______________
91 void AliEMCALTriggerSTU::L1( L1TriggerType_t type )
92 {
93         //
94         SlidingWindow( type, int(ThresholdFromV0( type )) );    
95 }
96
97 //________________
98 void AliEMCALTriggerSTU::PrintADC( L1TriggerType_t type, TVector2& pos, TVector2& idx )
99 {
100         //
101         Int_t ix = (Int_t) (( pos.X() + fPatchSize->X() ) * fSubRegionSize->X());
102         Int_t iy = (Int_t) (( pos.Y() + fPatchSize->Y() ) * fSubRegionSize->Y());
103         
104         TString subRegionADC[] = {"0->15", "16->31", "32->47", "48->63", "64->79", "80->95"};
105         
106         switch ( type )
107         {
108                 case kGamma:
109                 {
110                         Int_t iTRU = ( (ix-1) < 24 ) ? 31 - int(pos.Y() / 4) : 15 - int(pos.Y() / 4);
111                         
112                         printf("TRU #%d row #%d col #%d fastor: ",iTRU,int(idx.Y()),int(idx.X()));
113                         
114                         for (Int_t i=(Int_t)(pos.X() * fSubRegionSize->X());i<ix;i++) 
115                         {
116                           for (Int_t j=(Int_t) (pos.Y() * fSubRegionSize->Y());j<iy;j++) 
117                                 {
118                                         Int_t jtru = ( i < 24 ) ? 31 - j / 4 : 15 - j / 4;
119                                         printf("TRU#%d_%d ",jtru,fMap[i][j]);
120                                 }
121                         }
122                         
123                         cout << endl;
124                 }       
125                 break;
126                 case kJet:
127                 {
128                         //Int_t jTRU = ( (ix-1) < 24 ) ? 31 - (iy-1) / 4 : 15 - (iy-1) / 4;
129                         
130                         printf("jet found at row : %d and col : %d",int(idx.X()),int(idx.Y()));
131                         
132                         Char_t* vPair = 0x0;
133                         Int_t nSubRegion = 0;
134                         
135                         for (Int_t i=(Int_t)(pos.X() * fSubRegionSize->X());i<ix;i++) 
136                         {
137                           for (Int_t j=(Int_t)(pos.Y() * fSubRegionSize->Y());j<iy;j++) 
138                                 {
139                                         Int_t itru = ( i < 24 ) ? 31 - j / 4 : 15 - j / 4;
140                                         
141                                         Int_t idSR = fMap[i][j]/16;
142                                         
143                                         Char_t value = ((itru << 3) & 0xF8) | (idSR & 0x7);
144                                         
145                                         Bool_t isFound = kFALSE;
146                                         
147                                         for (Int_t k=0;k<nSubRegion && nSubRegion;k++)
148                                         {
149                                                 if (vPair[k] == value) isFound = kTRUE;
150                                         }
151                                         
152                                         if (!isFound) 
153                                         {       
154                                                 nSubRegion++;
155                                                 vPair = (Char_t*)realloc(vPair, nSubRegion * sizeof(Char_t));
156                                                 if (vPair == NULL) {AliError("Error (re)allocating PrintADC() memory");}
157                                                 
158                                                 vPair[nSubRegion-1] = value;
159                                         }
160                                 }
161                         }
162                         
163                         cout << " fastor:"; 
164                         for (Int_t i=0;i<nSubRegion;i++)
165                         {
166                                 cout << " TRU#" << ((vPair[i] & 0xF8) >> 3) << "_" << subRegionADC[(vPair[i] & 0x7)];
167                         }
168                 
169                         cout << endl;
170                         if (vPair) delete[] vPair;
171                 }
172                 break;
173                 default:
174                         AliError("AliEMCALTriggerSTU::PrintADC(): Undefined trigger type, pls check!");
175         }
176 }
177
178 //________________
179 void AliEMCALTriggerSTU::V0Multiplicity( TTree& treeV0 )
180 {  
181         //
182     AliCDBManager *man = AliCDBManager::Instance();
183     AliCDBEntry *entry = man->Get("VZERO/Calib/Data");
184     AliVZEROCalibData *calibdata = (AliVZEROCalibData*)entry->GetObject();
185         
186     TClonesArray* digitsArray = 0x0;
187     treeV0.SetBranchAddress("VZERODigit",&digitsArray);
188
189         Float_t mult[64];
190         Short_t  adc[64];
191    
192         for (Int_t i=0; i<64; i++)
193         {
194                 adc[i]    = 0;
195                 mult[i]   = 0.0;
196         }
197
198         Int_t nEntries = (Int_t)treeV0.GetEntries();
199
200         for (Int_t e=0; e<nEntries; e++) 
201         {
202                 treeV0.GetEvent(e);
203
204                 Int_t nDigits = digitsArray->GetEntriesFast();
205           
206                 for (Int_t d=0; d<nDigits; d++) 
207                 {    
208                         AliVZEROdigit* digit = (AliVZEROdigit*)digitsArray->At(d);      
209                         Int_t  pmNumber      = digit->PMNumber();
210                         
211                         if (adc[pmNumber] > (int(1.0/calibdata->GetMIPperADC(pmNumber)) /2) ) 
212                                 mult[pmNumber] += float(adc[pmNumber])*calibdata->GetMIPperADC(pmNumber);
213                 }
214         }
215   
216         //  0..31 V0C 
217         // 32..63 V0A
218         for (Int_t j=0; j<32; j++) 
219         {
220                 fV0M[0] += short(mult[j   ]+0.5); 
221                 fV0M[1] += short(mult[j+32]+0.5); 
222         }
223 }
224
225 //________________
226 void AliEMCALTriggerSTU::FetchFOR( Int_t iTRU, Int_t **R, const TVector2* rSize )
227 {
228         // L1 triggers run over the whole EMCal surface
229         // STU builds its own fRegion aggregating TRU fRegion into one 
230         
231         // STU I from TRUs O in Olivier's coordinate system
232         
233         if ( iTRU == 31 ) iTRU = 35;
234                 
235         Int_t i2y = iTRU / 3 / 2;       
236         
237         if ( ( iTRU / 3 ) % 2 ) // C side odd (z<0)
238         {
239                 Int_t i1y = 2 - ( iTRU - int( iTRU / 3 ) * 3 ); // 0 1 2 w/ increasing phi
240                 
241                 for (Int_t i=0; i<rSize->X(); i++)                                            //  0:23 0:4 
242                         for (Int_t j=0; j<rSize->Y(); j++) fRegion[24+i][j + i1y * 4 + i2y * 12] = R[i][j];
243         }
244         else                    // A side
245         {
246                 Int_t i1y =       iTRU - int( iTRU / 3 ) * 3;
247                 
248                 for (Int_t i=0; i<rSize->X(); i++)
249                         for (Int_t j=0; j<rSize->Y(); j++) fRegion[   i][j + i1y * 4 + i2y * 12] = R[i][j];
250         }
251 }
252
253 //___________
254 void AliEMCALTriggerSTU::PatchGenerator(const TClonesArray* lpos, Int_t val)
255 {
256         ZeroRegion();
257         
258         Int_t vTRU[32][24][4] ;//= {0};
259         
260         for (Int_t i = 0; i < 32; i++) 
261                 for (Int_t j = 0; j < 24; j++) 
262                         for (Int_t k = 0; k < 4; k++) vTRU[i][j][k]=0;
263         
264         
265         AliWarning("AliEMCALTriggerSTU::PatchGenerator(): STU region has been reset!");
266         
267         // Fill the patch FOR at 'pos' w/ value 'val'
268         
269         TIter NextPosition( lpos );
270         
271         while ( TVector2 *pos = (TVector2*)NextPosition() )
272         {
273                 pos->Print();
274                 for (Int_t i=(Int_t)(pos->X()*fSubRegionSize->X()); i<int((pos->X()+fPatchSize->X())*fSubRegionSize->X()); i++)
275                   for (Int_t j=(Int_t)(pos->Y()*fSubRegionSize->Y()); j<int((pos->Y()+fPatchSize->Y())*fSubRegionSize->Y()); j++) 
276                                 fRegion[i][j] = val;
277         }
278         
279         for (Int_t i=0; i<2; i++)
280         {
281                 for (Int_t j=0; j<16; j++)
282                 {
283                         Int_t iTRU = ( !i ) ? 31 - j : 15 - j;
284                         
285                         for (Int_t i1=24*i; i1<24*(i+1); i1++)
286                         {
287                                 for (Int_t j1=4*j; j1<4*(j+1); j1++)
288                                 {
289                                         vTRU[iTRU][i1%24][j1%4] = fRegion[i1][j1];
290                                 }
291                         }
292                 }
293         }
294         
295         gSystem->Exec(Form("mkdir -p GP"));
296
297         for (Int_t i=0; i<32; i++)
298         {
299                 std::ofstream outfile(Form("GP/data_TRU%d.txt",i),std::ios::trunc);
300         
301                 for (Int_t j=0;j<96;j++) 
302                 {
303                         Int_t ietam, iphim;
304                         
305                         if ( int(i / 16) )
306                         {
307                                 ietam =      j/4;
308                                 iphim =  3 - j%4;
309                         }
310                         else
311                         {                                       
312                                 ietam = 23 - j/4;
313                                 iphim =      j%4;
314                         }
315                         
316                         outfile << vTRU[i][ietam][iphim] << endl;
317                 }
318         
319                 outfile.close();
320         }
321 }
322
323 //___________
324 Float_t AliEMCALTriggerSTU::ThresholdFromV0( L1TriggerType_t type )
325 {       
326         // Compute threshold FIXME: need an access to the OCDB
327         // to get f(V0) parameters depending on trigger type
328         
329         switch ( type )
330         {
331                 case kGamma:
332                         break;
333                 case kJet:
334 //                      return 15.;
335                         break;
336                 default:
337                         AliError("AliEMCALTriggerSTU::ThresholdFromV0(): Undefined trigger type, pls check!");
338         }
339         
340         return 0.;
341 }
342
343 //__________
344 void AliEMCALTriggerSTU::Reset()
345 {
346         fPatches->Delete();
347 }