Corrected UInt_t <-> Int_t conversion
[u/mrichter/AliRoot.git] / TPC / AliTPCMonitorAltro.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 $Log$
18 Revision 1.2  2007/10/12 13:36:27  cvetan
19 Coding convention fixes from Stefan
20
21 Revision 1.1  2007/09/17 10:23:31  cvetan
22 New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.
23
24 */ 
25
26 ////////////////////////////////////////////////////////////////////////
27 ////
28 //// AliTPCMonitorAltro class
29 ////
30 //// Class for decoding raw TPC data in the ALTRO format.
31 //// Data are transformed from 32 bit words to 10 bit or 40 bit respectively.
32 //// The whole payload is transformed at once and written to an array. 
33 //// The single channels are decoded starting from the trailer word which is
34 //// decoded by DecodeTrailer(Int_t pos)
35 ////
36 //// Authors: Roland Bramm, 
37 ////          Stefan Kniege, IKF, Frankfurt
38 ////       
39 /////////////////////////////////////////////////////////////////////////
40
41
42 #include "AliTPCMonitorAltro.h"
43 #include "AliLog.h" 
44 #include <Riostream.h>
45 using namespace std;
46 ClassImp(AliTPCMonitorAltro)  
47
48 //_____________________________________________________________________________________________
49 AliTPCMonitorAltro::AliTPCMonitorAltro(UInt_t* memory, Int_t size, Int_t fformat) :
50   fverb(0),
51   fmemory(memory),
52   fsize(size),
53   f40BitArray(0),
54   f10BitArray(0),
55   fdecoderPos(0),
56   fallocate40BitArray(false),
57   fallocate10BitArray(false),
58   foffset(0),  
59   fwrite10bit(0),
60   fTrailerNWords(0), 
61   fTrailerHwAddress(0),
62   fTrailerDataPos(0),
63   fTrailerBlockPos(0),
64   fTrailerPos(0),
65   fNextPos(0),
66   ffilename()
67 {
68   // Constructor: Set different CDH offsets for ROOT (0) and date format
69   // Data offset can be changed via SetDataOffset(Int_t val)
70
71   if(     fformat==0) foffset=7; // old CHD Format
72   else if(fformat==1) foffset=8; // memory pointer from DATE (start CDH)
73   else if(fformat==2) foffset=0; // memory pointer from ROOT (after CDH)
74
75
76
77 //_____________________________________________________________________________________________
78 AliTPCMonitorAltro::AliTPCMonitorAltro(const AliTPCMonitorAltro &altro) :
79   TNamed(altro),
80   fverb(altro.fverb),
81   fmemory(altro.fmemory),
82   fsize(altro.fsize),
83   f40BitArray(altro.f40BitArray),
84   f10BitArray(altro.f10BitArray),
85   fdecoderPos(altro.fdecoderPos),
86   fallocate40BitArray(altro.fallocate40BitArray),
87   fallocate10BitArray(altro.fallocate10BitArray),
88   foffset(altro.foffset),
89   fwrite10bit(altro.fwrite10bit),
90   fTrailerNWords(altro.fTrailerNWords),
91   fTrailerHwAddress(altro.fTrailerHwAddress),
92   fTrailerDataPos(altro.fTrailerDataPos),
93   fTrailerBlockPos(altro.fTrailerBlockPos),
94   fTrailerPos(altro.fTrailerPos),
95   fNextPos(altro.fNextPos),
96   ffilename(altro.ffilename)
97 {
98   // copy constructor
99
100 }
101
102 //_____________________________________________________________________________________________
103 AliTPCMonitorAltro &AliTPCMonitorAltro::operator =(const AliTPCMonitorAltro& altro)
104 {
105   // assignement operator 
106   
107   if(this!=&altro){ 
108     ((TNamed *)this)->operator=(altro);
109     fverb=altro.fverb;
110     fmemory=altro.fmemory;
111     fsize=altro.fsize;
112     f40BitArray=altro.f40BitArray;
113     f10BitArray=altro.f10BitArray;
114     fdecoderPos=altro.fdecoderPos;
115     fallocate40BitArray=altro.fallocate40BitArray;
116     fallocate10BitArray=altro.fallocate10BitArray;
117     foffset=altro.foffset;
118     fwrite10bit=altro.fwrite10bit;
119     fTrailerNWords=altro.fTrailerNWords;
120     fTrailerHwAddress=altro.fTrailerHwAddress;
121     fTrailerDataPos=altro.fTrailerDataPos;
122     fTrailerBlockPos=altro.fTrailerBlockPos;
123     fTrailerPos=altro.fTrailerPos; 
124     fNextPos=altro.fNextPos;
125     ffilename = altro.ffilename;
126   }
127   return *this;
128 }
129
130
131 //_____________________________________________________________________________________________
132 AliTPCMonitorAltro::~AliTPCMonitorAltro() {
133   // Destructor
134   if(fallocate40BitArray == true) delete[] f40BitArray;
135   if(fallocate10BitArray == true) delete[] f10BitArray;
136  }
137
138 //_____________________________________________________________________________________________
139 void AliTPCMonitorAltro::Allocate40BitArray() 
140 {
141   // create array for 40 bit decoded data
142   fallocate40BitArray = true;
143   f40BitArray = new long long[Get40BitArraySize()];
144 }
145
146 //_____________________________________________________________________________________________
147 void AliTPCMonitorAltro::Allocate10BitArray() 
148 {
149   // Create array for 10 bit decoded data
150   fallocate10BitArray = true;
151   f10BitArray = new Short_t[Get10BitArraySize()];
152
153
154 //_____________________________________________________________________________________________
155 long long *AliTPCMonitorAltro::Get40BitArray() 
156 {
157   // Return pointer to array for 40 bit decoded data 
158   return f40BitArray;
159 }
160
161 //_____________________________________________________________________________________________
162 Short_t *AliTPCMonitorAltro::Get10BitArray() 
163 {
164   // Return pointer to array for 10 bit decoded data 
165   return f10BitArray;
166 }
167
168 // //_____________________________________________________________________________________________
169 // Int_t AliTPCMonitorAltro::Get40BitArraySize() 
170 // {
171 //   // Return number of 40 bit words in payload 
172 //   return fmemory[fsize-1];
173 // }
174
175 // //_____________________________________________________________________________________________
176 // Int_t AliTPCMonitorAltro::Get10BitArraySize() 
177 // { 
178 //   // Return number of 10 bit words in payload 
179 //   return fmemory[fsize-1]*4;
180 // }
181
182 //_____________________________________________________________________________________________
183 void AliTPCMonitorAltro::Decodeto40Bit() 
184 {
185   // Decode 32 bit words in fmemory to 40 bit words
186   Long64_t blackbox = 0;
187   Int_t rest;
188   
189   for(Int_t i = 0; i < Get40BitArraySize(); i++) 
190     {
191       rest = i%4;
192       switch(rest) {
193       case 0:
194         blackbox = (fmemory[foffset])     + (((Long64_t)(fmemory[foffset+1]&fgk08BitOn))<<32);
195         foffset +=1;
196         break;
197       case 1:
198         blackbox = (fmemory[foffset]>>8 ) + (((Long64_t)(fmemory[foffset+1]&fgk16BitOn))<<24);
199         foffset +=1;
200         break;
201       case 2:
202         blackbox = (fmemory[foffset]>>16) + (((Long64_t)(fmemory[foffset+1]&fgk24BitOn))<<16);
203         foffset +=1;
204         break;
205       case 3:
206         blackbox = (fmemory[foffset]>>24) + (((Long64_t)(fmemory[foffset+1]         ))<< 8);
207         foffset +=2;
208         break;
209       default:
210         blackbox = 0;
211         break;
212       }
213       f40BitArray[i] = blackbox;
214     }
215 }
216
217 //_____________________________________________________________________________________________
218 void AliTPCMonitorAltro::Decodeto10Bit(Int_t equipment) 
219 {
220   // Decode 32 bit words in fmemory to 10 bit words.
221   // Write words to file if fwrite10bit ("Write 10 bit" in Monitor.C Gui ) is set
222
223   Long64_t blackbox = 0;
224   Int_t    rest     = 0;
225   
226   ofstream datout;
227   if(fwrite10bit)
228   {
229     TString nameout=Form("%s_PayloadEquipmentId_%03i.txt",ffilename.Data(),equipment);
230     datout.open(nameout.Data());
231     AliInfo(Form("AliTPCMonitorAltro::decodeto10Bit :  Write Data to %s",nameout.Data()));
232     if(foffset==0) datout <<  "Payload without CDH in 10bit words " << endl;
233     else           datout  << "CDH in 32 bit hex words words (" << foffset << " lines )  followed by payload in 10 bit words " << endl;
234     for(Int_t ih = 0; ih< foffset ; ih++)
235     {
236       datout << hex << fmemory[ih] << endl;
237     }
238   }
239   
240   for(Int_t ind = 0; ind < Get40BitArraySize(); ind++)
241   {
242     rest = ind%4;
243     switch(rest)
244     {
245     case 0:
246       blackbox = (fmemory[foffset])     + (((Long64_t)(fmemory[foffset+1]&fgk08BitOn))<<32);
247       foffset +=1;
248       break;
249     case 1:
250       blackbox = (fmemory[foffset]>>8 ) + (((Long64_t)(fmemory[foffset+1]&fgk16BitOn))<<24);
251       foffset +=1;
252       break;
253     case 2:
254       blackbox = (fmemory[foffset]>>16) + (((Long64_t)(fmemory[foffset+1]&fgk24BitOn))<<16);
255       foffset +=1;
256       break;
257     case 3:
258       blackbox = (fmemory[foffset]>>24) + (((Long64_t)(fmemory[foffset+1]         ))<< 8);
259       foffset +=2;
260       break;
261     default:
262       blackbox = 0;
263       break;
264     }
265     f10BitArray[ind*4+0] = (Short_t)( blackbox & fgkmask10 )    ;
266     f10BitArray[ind*4+1] = (Short_t)((blackbox & fgkmask20)>>10);
267     f10BitArray[ind*4+2] = (Short_t)((blackbox & fgkmask30)>>20);
268     f10BitArray[ind*4+3] = (Short_t)((blackbox & fgkmask40)>>30);
269   }
270   if(fwrite10bit)
271   {
272     for(Int_t ind = 0; ind < Get40BitArraySize(); ind++)
273     {
274       datout << dec <<  f10BitArray[ind*4+0] << "\n";
275       datout << dec <<  f10BitArray[ind*4+1] << "\n";
276       datout << dec <<  f10BitArray[ind*4+2] << "\n";
277       datout << dec <<  f10BitArray[ind*4+3] << "\n";
278     }
279   }
280   
281   if(fwrite10bit) datout.close();
282 }
283
284 //_____________________________________________________________________________________________
285 Int_t AliTPCMonitorAltro::DecodeTrailer(Int_t pos)
286 {
287   // Decode the trailer word starting at position pos in fmemory
288   // Check if information leads to proper next trailer position
289   if (GetAltroVersion()==0xaabb) return DecodeTrailerVbb(pos);
290   fTrailerPos = pos;
291   if(pos<=4) return 0;
292   
293   Long64_t  words         = 0;
294   Long64_t  tail          = 0;
295   Long64_t  trailer       = 0;
296   Long64_t  carry         = 0;
297   Long64_t  rest          = 0 ;
298     
299   for(Long64_t  iter = 0 ; iter<4;iter++)
300     {
301       carry =  f10BitArray[pos-iter] ; 
302       carry = ( carry << (30- ((iter)*10)));
303       trailer += carry ;
304     }
305   
306   fTrailerHwAddress = (trailer & ((Long64_t )fgkTrailerMaskHardw)  );
307   words             = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskNWords))>>16);
308   tail           = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskTail   ))>>26 );
309   
310   if(words%4!=0) rest =  4-(words%4);
311   fTrailerNWords      = words+rest ;
312   fTrailerDataPos     = pos -4 -rest ;
313   fTrailerBlockPos    = pos -4 ;
314   fNextPos            = (pos -fTrailerNWords -4);
315   
316   if(       tail!=fgkTrailerTail        ) { AliError(Form("Could not read Trailer. \"Write 10bit\" for this event. Last Trailer line (2AA): %i. Supp.next Trailer line (2AA): %i ",pos,fNextPos));    return -1;      }
317   else if(     fNextPos==-1           ) { /* was last channel  */                                                                                                                                   return  0;      }
318   else if(     fNextPos <0            ) { AliError("Next Trailer position < 0 ");                                                                                                                   return -1;      }
319   else if((f10BitArray[fNextPos]!=682)) { AliError(Form("Could not find tail (2AA) at next supposed position %i",fNextPos));                                                                        return -1;      }
320   else                                  {                                                                                                                                                           return fNextPos;}
321   
322 }
323
324 //_____________________________________________________________________________________________
325 Int_t AliTPCMonitorAltro::DecodeTrailerVbb(Int_t pos)
326 {
327   // Decode the trailer word starting at position pos in fmemory
328   // Check if information leads to proper next trailer position
329     fTrailerPos = pos;
330   if(pos>Get10BitArraySize()-4) return 0;
331   
332   Long64_t  words         = 0;
333   Long64_t  tail          = 0;
334   Long64_t  trailer       = 0;
335   Long64_t  carry         = 0;
336   Long64_t  rest          = 0 ;
337   
338   for(Long64_t  iter = 0 ; iter<4;iter++)
339   {
340     carry =  f10BitArray[pos-iter] ;
341     carry = ( carry << (30- ((iter)*10)));
342     trailer += carry ;
343   }
344   
345   fTrailerHwAddress = (trailer & ((Long64_t )fgkTrailerMaskHardw)  );
346   words             = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskNWords))>>16);
347   tail           = (Long64_t )( (trailer & ((Long64_t )fgkTrailerMaskTail   ))>>26 );
348
349     //Decide on read direction (sign) from the RCU trailer information
350   Int_t sign=-1;
351   if (GetAltroVersion()==0xaabb) sign=1;
352   
353   if(words%4!=0) rest =  4-(words%4);
354   fTrailerNWords      = words+rest ;
355   fTrailerDataPos     = pos +sign*(4+rest) ;
356   fTrailerBlockPos    = pos +sign*4 ;
357   fNextPos            = (pos +sign*(fTrailerNWords+4));
358   
359   if(       tail==fgkTrailerTailErr        ) {
360     AliError(Form("Found Altro header with error marker (2AEE)[%0llx]: %i. Supp.next Trailer line (2AA)[%0x]: %i ",
361                   tail,pos,f10BitArray[fNextPos],fNextPos));
362     return -fNextPos;
363   } else if ( tail!=fgkTrailerTail        ) {
364     AliError(Form("Could not read Trailer. \"Write 10bit\" for this event. Last Trailer line (2AA)[%0llx]: %i. Supp.next Trailer line (2AA)[%0x]: %i ",
365                   tail,pos,f10BitArray[fNextPos],fNextPos));    return -1;
366   } else if(     fNextPos==Get10BitArraySize()+3           ) { /* was last channel  */
367     return  0;
368   }  else if(     fNextPos >=Get10BitArraySize()            ) {
369     AliError(Form("Next Trailer position < 0 %i", fNextPos));
370     return -1;
371   } else if((f10BitArray[fNextPos]!=682)&&(f10BitArray[fNextPos]!=686)) {
372     AliError(Form("Could not find tail (2AA) at next supposed position %i",fNextPos));
373     return -1;
374   } else {
375     return fNextPos;
376   }
377   
378 }
379
380