.so cleanup: removed from gSystem->Load()
[u/mrichter/AliRoot.git] / HLT / TPCLib / test / testAliHLTTPCDigitReaderDecoder.C
1 // $Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * ALICE Experiment at CERN, All rights reserved.                         *
6  *                                                                        *
7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8  *                  for The ALICE HLT Project.                            *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /** @file   testAliHLTTPCDigitReaderDecoder.C
20     @author Matthias Richter
21     @date   
22     @brief  Test macro/program for the AliHLTTPCDigitReaderDecoder
23  */
24
25 #ifndef __CINT__
26 #include "TSystem.h"
27 #include "AliHLTSystem.h"
28 #include "AliRawDataHeader.h"
29 #include "AliHLTAltroGenerator.h"
30 #include "AliHLTTPCDigitReaderDecoder.h"
31 #include <ostream>
32 #endif //__CINT__
33
34 #ifndef __CINT__
35 const int sizeofAliRawDataHeader=sizeof(AliRawDataHeader);
36 #else
37 // cint does not handle sizeof correctly
38 const int sizeofAliRawDataHeader=32;
39 #endif
40
41 /////////////////////////////////////////////////////////////////
42 /////////////////////////////////////////////////////////////////
43 /////////////////////////////////////////////////////////////////
44 //
45 // configuration of the test program
46 //
47
48 // printouts or not
49 const bool bVerbose=true;
50
51 // some defaults
52 const int maxChannels=10;
53 const int maxBunches=10;
54 const int maxBunchLength=10;
55 const int maxTimebin=1024;
56 const int maxSignal=1024;
57
58 /////////////////////////////////////////////////////////////////
59 /////////////////////////////////////////////////////////////////
60 /////////////////////////////////////////////////////////////////
61
62 int testAliHLTTPCDigitReaderDecoder()
63 {
64   int iResult=0;
65 #ifdef __CINT__
66   gSystem->Load("libAliHLTUtil");
67   gSystem->Load("libAliHLTRCU");
68   gSystem->Load("libAliHLTTPC");
69 #endif
70   AliHLTSystem gHLT;
71
72   AliHLTAltroGenerator generator(maxChannels, maxBunches, maxBunchLength, maxTimebin, maxSignal);
73   //generator.SetDirection(AliHLTAltroGenerator::kForwards);
74   if ((iResult=generator.Generate())<0) return iResult;
75
76   ///////////////////////////////////////////////////////////////////////////////////////////////////
77   if (bVerbose) {
78     cout << "***************************************************************" << endl;
79     cout << "************** Dumping simulated Altro data *******************" << endl;
80     generator.Print();
81     cout << endl;
82   }
83
84   ///////////////////////////////////////////////////////////////////////////////////////////////////
85   AliRawDataHeader cdh;
86   generator.SetCDH(&cdh, 32);
87
88   UInt_t trailer=0;
89   generator.SetRCUTrailer((UChar_t*)&trailer, 4);
90
91   UChar_t* pBuffer=NULL;
92   Int_t size=generator.GetData(pBuffer);
93
94   int partition=0;
95   if (bVerbose) {
96     AliHLTTPCDigitReaderDecoder decoder;
97     decoder.SetUnsorted(true);
98     if ((iResult=decoder.InitBlock(pBuffer, size, partition, 0))>=0) {
99       cout << "***************************************************************" << endl;
100       cout << "********************** reading bunch model  *******************" << endl;
101       while (iResult>=0 && decoder.NextChannel()) {
102         cout << "***************************************************************" << endl;
103         cout << "channel address: " << decoder.GetAltroBlockHWaddr() << endl;
104
105         while (iResult>=0 && decoder.NextBunch()) {
106           int bunchLength=decoder.GetBunchSize();
107           cout << "   length " << bunchLength << " time " << decoder.GetTime() << ":     ";
108           const UInt_t* pData=decoder.GetSignals();
109           while (bunchLength-->0 && pData) {
110             cout << " " << *pData++;
111           }
112           cout << endl;
113         }
114       }
115       cout << endl;
116     }
117   }   
118
119   ///////////////////////////////////////////////////////////////////////////////////////////////////
120   if (bVerbose) {
121     AliHLTTPCDigitReaderDecoder decoder;
122     decoder.SetUnsorted(true);
123     if ((iResult=decoder.InitBlock(pBuffer, size, partition, 0))>=0) {
124       int lastChannel=-1;
125       int lastTime=-1;
126       cout << "***************************************************************" << endl;
127       cout << "********************** reading stream model *******************" << endl;
128       while (iResult>=0 && decoder.Next()) {
129         if (lastTime>=0 && lastTime!=decoder.GetTime()+1 && lastTime!=decoder.GetTime()-1)
130           cout << endl;
131         
132         if (lastChannel<0 || lastChannel!=(int)decoder.GetAltroBlockHWaddr()) {
133           cout << "***************************************************************" << endl;
134           cout << "channel address: " << decoder.GetAltroBlockHWaddr() << endl;
135         }
136
137         if (lastTime<0 || (lastTime!=decoder.GetTime()+1 && lastTime!=decoder.GetTime()-1))
138           cout << " time " << decoder.GetTime() << ":     ";
139
140         cout << " " << decoder.GetSignal();
141
142         lastChannel=decoder.GetAltroBlockHWaddr();
143         lastTime=decoder.GetTime();
144       }
145       cout << endl;
146       cout << endl;
147     }    
148   }
149
150   ///////////////////////////////////////////////////////////////////////////////////////////////////
151   if (bVerbose) {
152     cout << "***************************************************************" << endl;
153     cout << "********************* comparing encoded data ******************" << endl;
154     cout << "***************************************************************" << endl;
155   }
156
157   generator.Rewind();
158   AliHLTTPCDigitReaderDecoder decoder;
159   decoder.SetUnsorted(true);
160   if (iResult>=0) iResult=decoder.InitBlock(pBuffer, size, partition, 0);
161   while (iResult>=0 && decoder.NextChannel()) {
162     if (!generator.NextChannel()) {
163       cout << "error getting next simulated channel" << endl;
164       iResult=-1;
165       break;
166     }
167     int hwadd=decoder.GetAltroBlockHWaddr();
168     if (hwadd!=generator.GetHwAddress()) {
169       cout << "channel address missmatch: simulated " << generator.GetHwAddress() << " encoded " << hwadd << endl;
170       iResult=-1;
171       break;
172     }
173
174     if (bVerbose) cout << "comparing channel " << hwadd << endl;
175
176     while (iResult>=0 && decoder.NextBunch()) {
177       if (!generator.NextBunch()) {
178         cout << "error getting bunch in simulated data" <<endl;
179         iResult=-1;
180         break;
181       }
182       int bunchLength=decoder.GetBunchSize();
183       if (bunchLength!=(int)generator.GetBunchSize()) {
184         cout << "bunch length missmatch: simulated " << generator.GetBunchSize() << " encoded " << bunchLength << hex << " (" << bunchLength << ")" << dec << endl;
185         iResult=-1;
186         break;
187       }
188       int bunchStartTime=decoder.GetTime();
189         if (bunchStartTime!=(int)generator.GetStartTime()) {
190         cout << "bunch end time missmatch: simulated " << generator.GetStartTime() << " encoded " << bunchStartTime << endl;
191         iResult=-1;
192         break;
193       }
194       if (bVerbose) cout << " bunch length " << bunchLength << ", end time " << bunchStartTime << endl;
195       const  UInt_t* bunchData=decoder.GetSignals();
196       const  Short_t* simData=generator.GetSignals();
197       for (int bin=0; bin<bunchLength; bin++) {
198         if ((Short_t)bunchData[bin]!=simData[bin]) {
199           cout << "data missmatch at bunch position " << bin << " : simulated " << simData[bin] << " encoded " << bunchData[bin] << endl;
200           iResult=-1;
201           break;
202         }
203       }
204     }
205   }
206
207   return 0;
208 }
209
210 int main(int /*argc*/, const char** /*argv*/)
211 {
212   int iResult=0;
213   int iCount=1;
214   for (int i=0; i<iCount; i++) {
215     if ((iResult=testAliHLTTPCDigitReaderDecoder())<0) {
216       cout << "missmatch in cycle no " << i << endl;
217       return iResult;
218     }
219   }
220   cout << "checking: "<< iCount << " encoding cycle(s) successfully tested" << endl;
221   return 0;
222 }