]>
Commit | Line | Data |
---|---|---|
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 | /* $Id$ */ | |
17 | ||
18 | #include "AliTRDtestBeam.h" | |
19 | ||
20 | #include "AliTRDRawStreamTB.h" | |
21 | #include "AliRawReaderMemory.h" | |
22 | ||
23 | #include <iostream> | |
24 | #include <fstream> | |
25 | ||
26 | /* | |
27 | #include <sys/types.h> | |
28 | #include <sys/stat.h> | |
29 | #include <fcntl.h> | |
30 | #include <unistd.h> | |
31 | */ | |
32 | ||
33 | ClassImp(AliTRDtestBeam) | |
34 | ||
35 | const Long_t AliTRDtestBeam::fgkFileHeadSize = 544; // ? | |
36 | const Long_t AliTRDtestBeam::fgkEventHeadSize = 68; //? | |
37 | const Long_t AliTRDtestBeam::fgkLdcHeadSize = 68; //? | |
38 | const Long_t AliTRDtestBeam::fgkEquipHeadSize = 28; // | |
39 | const Int_t AliTRDtestBeam::fgkVmeIn =1; //VME event in | |
40 | const Int_t AliTRDtestBeam::fgkSimIn =1; //Si-strips in | |
41 | ||
42 | //typedef char byte; | |
43 | ||
44 | //offsets in bytes | |
45 | const Int_t AliTRDtestBeam::fgkPosRun = 20; //run nr. (in file and event header) | |
46 | const Int_t AliTRDtestBeam::fgkPosLength = 0; //event/equip. length | |
47 | const Int_t AliTRDtestBeam::fgkEqId = 8; //equipment id. | |
48 | const Int_t AliTRDtestBeam::fgkPosSiOff = 12; //Si data size offset (3 extra words!!!) | |
49 | ||
50 | using namespace std; | |
51 | ||
52 | //____________________________________________________________________________ | |
53 | AliTRDtestBeam::AliTRDtestBeam() : | |
54 | fDataStream(0), | |
55 | fHeaderIsRead(0), | |
56 | fEventCount(0), | |
57 | fLimit(4), | |
58 | fCurrent(0), | |
59 | fDdlOff(0), | |
60 | fSiOff(0), | |
61 | fQdcOff(0), | |
62 | fDdlSize(0), | |
63 | fFileHeader(0), | |
64 | fEventHeader(0), | |
65 | fEventData(0), | |
66 | fNSi1(0), | |
67 | fNSi2(0), | |
68 | fCher(0), | |
69 | fPb(0) | |
70 | { | |
71 | // | |
72 | // Standard construction | |
73 | // | |
74 | ||
75 | } | |
76 | //____________________________________________________________________________ | |
77 | AliTRDtestBeam::AliTRDtestBeam(const char *filename) : | |
78 | fDataStream(0), | |
79 | fHeaderIsRead(0), | |
80 | fEventCount(0), | |
81 | fLimit(4), | |
82 | fCurrent(0), | |
83 | fDdlOff(0), | |
84 | fSiOff(0), | |
85 | fQdcOff(0), | |
86 | fDdlSize(0), | |
87 | fFileHeader(0), | |
88 | fEventHeader(0), | |
89 | fEventData(0), | |
90 | fNSi1(0), | |
91 | fNSi2(0), | |
92 | fCher(0), | |
93 | fPb(0) | |
94 | { | |
95 | // | |
96 | // AliTRDtestBeam constructor | |
97 | // | |
98 | ||
99 | fDataStream = new ifstream(filename, ifstream::in | ifstream::binary ); | |
100 | cout << fDataStream->is_open() << endl; | |
101 | //fHeaderIsRead = kTRUE; | |
102 | fHeaderIsRead = kTRUE; | |
103 | ||
104 | fFileHeader = new Char_t[fgkFileHeadSize]; | |
105 | fEventHeader = new Char_t[fgkEventHeadSize]; | |
106 | fEventData = new Char_t[fLimit]; | |
107 | ||
108 | } | |
109 | ||
110 | //____________________________________________________________________________ | |
111 | AliTRDtestBeam::~AliTRDtestBeam() | |
112 | { | |
113 | // | |
114 | // Destructor | |
115 | // | |
116 | ||
117 | if (fDataStream) delete fDataStream; | |
118 | if (fEventHeader) delete fEventHeader; | |
119 | if (fFileHeader) delete fFileHeader; | |
120 | if (fEventData) delete fEventData; | |
121 | ||
122 | } | |
123 | ||
124 | //____________________________________________________________________________ | |
125 | Int_t AliTRDtestBeam::NextEvent() | |
126 | { | |
127 | // | |
128 | // Read the next event | |
129 | // | |
130 | ||
131 | Long_t dataSize=0,ldcOff; //,ldc_id,ldc2_id; | |
132 | Long_t ldcSize,eqId; //,ev_l2; | |
133 | Long_t eventNr,evL1; | |
134 | Long_t word; | |
135 | ||
136 | if ( !fHeaderIsRead ) { | |
137 | fDataStream->read(fFileHeader, fgkFileHeadSize); | |
138 | if(fDataStream->fail()) { | |
139 | cerr << "Error reading file header! " << endl; | |
140 | return false; | |
141 | } | |
142 | cout << " Run nr. " << Int(fgkPosRun, fFileHeader) << endl; | |
143 | fHeaderIsRead=kTRUE; | |
144 | } | |
145 | ||
146 | fDataStream->read(fEventHeader, fgkEventHeadSize); | |
147 | if(fDataStream->fail()) { | |
148 | cerr << "End of file, Event " << fEventCount << endl; | |
149 | return false; | |
150 | } | |
151 | ||
152 | dataSize = Int(fgkPosLength, fEventHeader)-fgkEventHeadSize; //? | |
153 | eventNr = Int((4+fgkPosRun), fEventHeader); //ev.nr. | |
154 | //cout << " Event " << eventNr <<" size "<< dataSize <<endl; | |
155 | ||
156 | if (eventNr <= fEventCount-1) { //watch-out ...event counter starts at 1? | |
157 | cout << fEventCount << " End of file?, Event " << fEventCount << endl; | |
158 | return false; | |
159 | } | |
160 | //cout << "Run " << Int(fgkPosRun, header)<< " , Event " <<eventNr <<endl; | |
161 | ||
162 | // enough space for data? | |
163 | if (fLimit < dataSize) { | |
164 | delete[] fEventData; | |
165 | fEventData = new Char_t[dataSize]; | |
166 | fLimit = dataSize; | |
167 | } | |
168 | ||
169 | fDataStream->read(fEventData, dataSize); | |
170 | ||
171 | if(fDataStream->fail()) { | |
172 | cerr << "End of file, Event " << fEventCount; // << endl; | |
173 | return false; | |
174 | } | |
175 | ||
176 | //cout << " ...IDs (size) : "; | |
177 | ||
178 | ldcOff=0; // size of data from one DDL link | |
179 | ||
180 | for ( size_t k = 0; k < 2; k++ ) { // 2 LDCs (DDL & VME) | |
181 | ||
182 | ldcSize = Int(ldcOff+fgkPosLength, fEventData); // | |
183 | //ldcSize1=(ldcSize-fgkLdcHeadSize); | |
184 | eqId = Int(ldcOff+fgkLdcHeadSize+fgkEqId, fEventData); | |
185 | //cout << eqId <<" ("<<ldcSize<<") "; | |
186 | ||
187 | evL1 = Int((4+ldcOff+fgkPosRun), fEventData); //ev.nr. | |
188 | if ( evL1 != eventNr ){ | |
189 | //cerr << "eqId " <<eqId<<" event nr. mismatch? " << eventNr <<" / "<< evL1 <<" ...LDC data size (header:68) " <<ldcSize<<endl; | |
190 | } | |
191 | ||
192 | if (eqId == 1024) { //DDL data | |
193 | fDdlOff = ldcOff; //+fgkLdcHeadSize+fgkEquipHeadSize + 32; | |
194 | fDdlSize = ldcSize; | |
195 | } | |
196 | ||
197 | if (eqId == 550) { //Si-strip data (+QDC) | |
198 | //cout << "550" << endl; | |
199 | fSiOff=ldcOff+fgkLdcHeadSize+fgkEquipHeadSize+fgkPosSiOff; | |
200 | word = Int(fSiOff, fEventData); | |
201 | Short_t lenSi1 = (word >> 16) & 0xffff; | |
202 | Short_t lenSi2 = word & 0xffff; | |
203 | fQdcOff=fSiOff+4*(lenSi1+lenSi2+1)+fgkEquipHeadSize+4; | |
204 | } | |
205 | else if (eqId == 1182) { //QDC first... | |
206 | //cout << "1182" << endl; | |
207 | fQdcOff=ldcOff+fgkLdcHeadSize+fgkEquipHeadSize+fgkPosSiOff; | |
208 | fSiOff=fQdcOff+fgkEquipHeadSize+4; | |
209 | } | |
210 | ||
211 | ldcOff=ldcSize; | |
212 | ||
213 | } | |
214 | //cout << endl; | |
215 | ||
216 | //cout << "DDL = " << fDdlOff << endl; | |
217 | // cout << "Si = " << fSiOff << endl; | |
218 | //cout << "QDC = " << fQdcOff << endl; | |
219 | ||
220 | DecodeSi(); | |
221 | ||
222 | fEventCount++; //event counter | |
223 | return true; | |
224 | } | |
225 | ||
226 | //____________________________________________________________________________ | |
227 | Int_t AliTRDtestBeam::DecodeSi() | |
228 | { | |
229 | // | |
230 | // Decode the silicon detector | |
231 | // | |
232 | ||
233 | if (fSiOff < 0) return 0; | |
234 | ||
235 | // cout << "decoding Si data" << endl; | |
236 | ||
237 | Long_t word; | |
238 | ||
239 | word=Int(fSiOff, fEventData); | |
240 | fNSi1 = (word >> 16) & 0xffff; | |
241 | fNSi2 = word & 0xffff; | |
242 | ||
243 | Int_t cSi=fSiOff; // | |
244 | for (int i = 0; i < fNSi1; i++) { | |
245 | fSi1Address[i] = ( Int(cSi, fEventData) >> 12 ) & 0x7ff; | |
246 | fSi1Charge[i] = Int(cSi, fEventData) & 0xfff; | |
247 | cSi+=4; | |
248 | } | |
249 | ||
250 | for (int i = 0; i < fNSi2; i++) { //1,for Date! | |
251 | fSi2Address[i] = ( Int(cSi, fEventData) >> 12 ) & 0x7ff; | |
252 | fSi2Charge[i] = Int(cSi, fEventData) & 0xfff; | |
253 | cSi+=4; | |
254 | } | |
255 | ||
256 | // reconstruction | |
257 | ||
258 | int aLenSiX = 640; | |
259 | ||
260 | int qmaxX; int amaxX; | |
261 | int qmaxY; int amaxY; | |
262 | ||
263 | qmaxX = 5; | |
264 | qmaxY = 5; | |
265 | amaxX = -1; | |
266 | amaxY = -1+aLenSiX; | |
267 | ||
268 | for( int i = 0; i < GetNSi1(); i++ ) { | |
269 | ||
270 | if (fSi1Address[i] == 0) continue; // noise | |
271 | ||
272 | if (fSi1Address[i] < aLenSiX ) { | |
273 | if( fSi1Charge[i] > qmaxX ) { | |
274 | qmaxX = fSi1Charge[i]; | |
275 | amaxX = fSi1Address[i]; | |
276 | } | |
277 | } else { | |
278 | if( fSi1Charge[i] > qmaxY ) { | |
279 | qmaxY = fSi1Charge[i]; | |
280 | amaxY = fSi1Address[i]; | |
281 | } | |
282 | } | |
283 | } | |
284 | ||
285 | fX[0] = (float)(amaxX*0.05); // [mm] | |
286 | fY[0] = (float)((amaxY-aLenSiX)*0.05); | |
287 | fQx[0] = (float)qmaxX; | |
288 | fQy[0] = (float)qmaxY; | |
289 | ||
290 | // | |
291 | qmaxX = 5; | |
292 | qmaxY = 5; | |
293 | amaxX = -1; | |
294 | amaxY = -1+aLenSiX; | |
295 | ||
296 | for( int i = 0; i < GetNSi2(); i++ ) { | |
297 | ||
298 | if (fSi2Address[i] == 1279) continue; // noise | |
299 | if (fSi2Address[i] == 0) continue; // noise | |
300 | ||
301 | if(fSi2Address[i] < aLenSiX) { | |
302 | if( fSi2Charge[i] > qmaxX ) { | |
303 | qmaxX = fSi2Charge[i]; | |
304 | amaxX = fSi2Address[i]; | |
305 | } | |
306 | } else { | |
307 | if( fSi2Charge[i] > qmaxY ) { | |
308 | //if (fSi2Charge[i] > 50) cout << fSi2Charge[i] << " " << i << " " << fSi2Address[i] << endl; | |
309 | qmaxY = fSi2Charge[i]; | |
310 | amaxY = fSi2Address[i]; | |
311 | } | |
312 | } | |
313 | } | |
314 | ||
315 | fX[1] = (float)(amaxX*0.05); // [mm] | |
316 | fY[1] = (float)((amaxY-aLenSiX)*0.05); | |
317 | fQx[1] = (float)qmaxX; | |
318 | fQy[1] = (float)qmaxY; | |
319 | ||
320 | if (fQdcOff < 0) return 0; | |
321 | ||
322 | word=Int(fQdcOff, fEventData); | |
323 | fPb = (Double_t)((word >> 16) & 0xFFF); | |
324 | fCher = (Double_t)((word ) & 0xFFF); | |
325 | ||
326 | //cout << fCher << " " << fPb << endl; | |
327 | return 1; | |
328 | ||
329 | } | |
330 | //____________________________________________________________________________ | |
331 | AliTRDRawStreamTB *AliTRDtestBeam::GetTRDrawStream() | |
332 | { | |
333 | // | |
334 | // Get the TRD raw stream | |
335 | // | |
336 | ||
337 | // needs AliTRDRawStreamTB | |
338 | //cout << "Chamber reader:" << (Int_t)(fEventData+fDdlOff) << " " << fDdlSize << endl; | |
339 | //int ifout = open("dump.dat", O_WRONLY | O_TRUNC | O_CREAT); | |
340 | //write(ifout, (void*)(fEventData+fDdlOff+16), fDdlSize); | |
341 | //close(ifout); | |
342 | ||
343 | AliRawReaderMemory *reader = new AliRawReaderMemory((UChar_t*)(fEventData+fDdlOff), (UInt_t)fDdlSize); | |
344 | reader->SetEquipmentID(1024); | |
345 | reader->ReadHeader(); | |
346 | AliTRDRawStreamTB::RawBufferMissAligned(kTRUE); | |
347 | AliTRDRawStreamTB::SupressWarnings(kTRUE); | |
348 | ||
349 | AliTRDRawStreamTB *tb = new AliTRDRawStreamTB(reader); | |
350 | tb->Init(); | |
351 | return tb; | |
352 | /* | |
353 | return | |
354 | ||
355 | AliRawReaderMemory *rmem = data->GetRawReader(); | |
356 | rmem->ReadHeader(); | |
357 | ||
358 | AliTRDRawStreamTB tb(rmem); | |
359 | tb.Init(); | |
360 | AliTRDRawStreamTB::SupressWarnings(kTRUE); | |
361 | ||
362 | */ | |
363 | } | |
364 | ||
365 | //____________________________________________________________________________ | |
366 | Int_t AliTRDtestBeam::Int(Int_t i, Char_t *start) | |
367 | { | |
368 | // | |
369 | // ????? | |
370 | // | |
371 | ||
372 | bool swap = kFALSE; | |
373 | ||
374 | if(swap) { | |
375 | char *q=(char*)(start+i); | |
376 | char p[] = {q[3], q[2], q[1], q[0]}; | |
377 | return *((int*) p); | |
378 | } else return *((int*)(start+i)); | |
379 | ||
380 | } | |
381 | ||
382 | //____________________________________________________________________________ |