]>
Commit | Line | Data |
---|---|---|
2e9f335b | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-2003, 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 | **************************************************************************/ | |
9f992f70 | 15 | |
30c1018e | 16 | /* $Id$ */ |
a79660fb | 17 | |
9f992f70 | 18 | |
a79660fb | 19 | //This class contains all the necessary methods to create the Raw Data |
20 | //files (slides) for the ITS data challenges for: | |
21 | //SPD | |
22 | //SDD | |
23 | //SSD | |
2e9f335b | 24 | |
25 | #include <stdlib.h> | |
5dfa68c5 | 26 | //#include <Riostream.h> |
2e9f335b | 27 | #include <TClonesArray.h> |
28 | #include <TTree.h> | |
7d62fb64 | 29 | #include "AliITSdigit.h" |
2e9f335b | 30 | #include "AliITSDDLRawData.h" |
f7ee745b | 31 | #include "AliRawDataHeaderSim.h" |
0421c3d1 | 32 | #include "AliITSRawStreamSPD.h" |
33 | #include "AliITSRawStreamSDD.h" | |
979b5a5f | 34 | #include "AliITSDDLModuleMapSDD.h" |
0421c3d1 | 35 | #include "AliITSRawStreamSSD.h" |
3f917533 | 36 | #include "AliITSIntMap.h" |
113c12f1 | 37 | #include "AliBitPacking.h" |
362c9d61 | 38 | #include "AliDAQ.h" |
08f92f14 | 39 | #include "AliFstream.h" |
ad7f2bfa | 40 | #include "AliITSFOSignalsSPD.h" |
2e9f335b | 41 | |
42 | ClassImp(AliITSDDLRawData) | |
43 | ||
44 | //////////////////////////////////////////////////////////////////////////////////////// | |
e56160b8 | 45 | AliITSDDLRawData::AliITSDDLRawData(): |
46 | fVerbose(0), | |
47 | fIndex(-1), | |
ad1b4ad1 | 48 | fHalfStaveModule(-1), |
d9ed1779 | 49 | fSDDRawFormat(7){ |
a79660fb | 50 | //Default constructor |
e56160b8 | 51 | |
2e9f335b | 52 | } |
53 | ||
54 | //////////////////////////////////////////////////////////////////////////////////////// | |
55 | ||
ac74f489 | 56 | AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) : |
e56160b8 | 57 | TObject(source), |
58 | fVerbose(source.fVerbose), | |
59 | fIndex(source.fIndex), | |
ad1b4ad1 | 60 | fHalfStaveModule(source.fHalfStaveModule), |
d9ed1779 | 61 | fSDDRawFormat(source.fSDDRawFormat){ |
a79660fb | 62 | //Copy Constructor |
2e9f335b | 63 | } |
64 | ||
65 | //////////////////////////////////////////////////////////////////////////////////////// | |
66 | ||
67 | AliITSDDLRawData& AliITSDDLRawData::operator=(const AliITSDDLRawData &source){ | |
68 | //Assigment operator | |
69 | this->fIndex=source.fIndex; | |
70 | this->fHalfStaveModule=source.fHalfStaveModule; | |
9f992f70 | 71 | this->fVerbose=source.fVerbose; |
d9ed1779 | 72 | this->fSDDRawFormat=source.fSDDRawFormat; |
2e9f335b | 73 | return *this; |
74 | } | |
75 | ||
76 | //////////////////////////////////////////////////////////////////////////////////////// | |
77 | //STRIP | |
78 | // | |
79 | ||
0b3c7dfc | 80 | void AliITSDDLRawData::GetDigitsSSD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){ |
a79660fb | 81 | //This method packs the SSD digits in a proper 32 bits structure |
532a132e | 82 | // Revised by Enrico Fragiacomo |
2e9f335b | 83 | Int_t ix; |
84 | Int_t iz; | |
85 | Int_t is; | |
0b3c7dfc | 86 | UInt_t word; |
87 | UInt_t baseWord; | |
2e9f335b | 88 | Int_t ndigits = ITSdigits->GetEntries(); |
89 | AliITSdigit *digs; | |
9f992f70 | 90 | ofstream ftxt; |
2e9f335b | 91 | if(ndigits){ |
9f992f70 | 92 | if (fVerbose==2){ |
93 | ftxt.open("SSDdigits.txt",ios::app); | |
94 | } | |
2e9f335b | 95 | for (Int_t digit=0;digit<ndigits;digit++) { |
96 | digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit); | |
532a132e | 97 | iz=digs->GetCoord1(); // If iz==0, O side and if iz=1 N side |
98 | ix=digs->GetCoord2(); // Strip Number | |
7f1a504b | 99 | is=digs->GetCompressedSignal(); // ADC Signal |
2e9f335b | 100 | // cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl; |
f957a032 | 101 | if(is<0) is = 0; |
102 | if(is>4095) is = 4095; | |
9f992f70 | 103 | if (fVerbose==2) |
104 | ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl; | |
532a132e | 105 | |
a79660fb | 106 | baseWord=0; |
532a132e | 107 | |
108 | word=is; | |
109 | AliBitPacking::PackWord(word,baseWord,0,11);//ADC data | |
110 | ||
111 | word = (iz==0) ? ix : 1535-ix ; // on N-side 1535-768 -> 0-767 | |
112 | AliBitPacking::PackWord(word,baseWord,12,22);//Strip Number | |
113 | ||
114 | word = mod%12; // ADC-number (12 ADCs per AD module) | |
115 | word += ( word<6 ) ? 0 : 2; // ADC range 0-5 and 8-13 | |
116 | AliBitPacking::PackWord(word,baseWord,24,27);//ADC Channel | |
117 | ||
118 | word = mod/12+1; // AD-number (AD module index ranges 1-9) | |
119 | AliBitPacking::PackWord(word,baseWord,28,31);//AD slot | |
2e9f335b | 120 | fIndex++; |
a79660fb | 121 | buf[fIndex]=baseWord; |
2e9f335b | 122 | }//end for |
123 | }//end if | |
9f992f70 | 124 | if (fVerbose==2) |
125 | ftxt.close(); | |
2e9f335b | 126 | return; |
127 | }//end GetDigitsSSD | |
128 | ||
129 | //////////////////////////////////////////////////////////////////////////////////////// | |
130 | //Silicon Drift Detector | |
131 | // | |
132 | ||
ad1b4ad1 | 133 | void AliITSDDLRawData::GetDigitsSDDCompressed(TClonesArray *ITSdigits, Int_t mod, UInt_t *buf){ |
134 | //This method packs the SDD digits in the compressed format (32 bit per digit) | |
135 | // see AliITSRawStreamSDDCompressed for details on the dta format | |
136 | ||
137 | UInt_t dataWord=0; | |
138 | Int_t ndigits = ITSdigits->GetEntries(); | |
139 | AliITSdigit *digs; | |
140 | if(ndigits){ | |
141 | for (Int_t digit=0;digit<ndigits;digit++) { | |
142 | digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit); | |
143 | Int_t iz=digs->GetCoord1(); // Anode | |
144 | Int_t ix=digs->GetCoord2(); // Time | |
6297cc01 | 145 | Int_t is=digs->GetCompressedSignal(); // ADC Signal - 8 bit |
ad1b4ad1 | 146 | dataWord=mod<<27; |
147 | Int_t sid=0; | |
148 | if(iz>=256){ | |
149 | sid=1; | |
150 | iz-=256; | |
151 | } | |
152 | dataWord+=sid<<26; | |
153 | dataWord+=iz<<18; | |
154 | dataWord+=ix<<10; | |
d9ed1779 | 155 | UInt_t adcEncoded=0; |
156 | Int_t shift=0; | |
157 | if(is < 8) shift=2; | |
158 | else if(is<16) shift=3; | |
159 | else if(is<32) shift=4; | |
160 | else if(is<64) shift=5; | |
161 | else if(is<128) shift=6; | |
162 | else shift=7; | |
163 | adcEncoded=shift+((is-(1<<shift))<<3); | |
164 | dataWord+=adcEncoded; | |
ad1b4ad1 | 165 | fIndex++; |
166 | buf[fIndex]=dataWord; | |
167 | } | |
168 | } | |
3ee08066 | 169 | UInt_t finalWord=UInt_t(15)<<28; |
ad1b4ad1 | 170 | finalWord+=mod; |
171 | fIndex++; | |
172 | buf[fIndex]=finalWord; | |
173 | } | |
174 | ||
175 | //______________________________________________________________________ | |
176 | ||
0b3c7dfc | 177 | void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){ |
a97b3678 | 178 | //This method packs the SDD digits in a proper 32 bits structure |
2e9f335b | 179 | Int_t ix; |
180 | Int_t iz; | |
181 | Int_t is; | |
a97b3678 | 182 | UInt_t word=0; |
183 | UInt_t baseWord=0; | |
2e9f335b | 184 | Int_t ndigits = ITSdigits->GetEntries(); |
185 | AliITSdigit *digs; | |
9f992f70 | 186 | ofstream ftxt; |
a97b3678 | 187 | Int_t digarr[512][256]; |
188 | for(Int_t i=0;i<512;i++){ | |
189 | for(Int_t j=0;j<256;j++){ | |
190 | digarr[i][j]=0; | |
191 | } | |
192 | } | |
193 | //word to select the 12 carlos for the 12 modules | |
14dceddf | 194 | UInt_t carlosid=0x30000000+mod; |
a97b3678 | 195 | |
196 | fIndex++; | |
197 | buf[fIndex]=carlosid; | |
198 | Int_t first=0; | |
199 | Int_t last=0; | |
200 | Int_t diff=0; | |
201 | Int_t nbit=0; | |
202 | UInt_t word2=0; | |
203 | Bool_t flag = kFALSE; | |
204 | baseWord=0; | |
205 | Int_t bitinfo1[4] = {3,8,3,7}; //vector with info on bit for timebin info | |
206 | Int_t wordinfo1[4]= {0,0,0,0}; //vector with word info for timebin info | |
207 | Int_t bitinfo2[2] = {3,18}; //vector with info on bit for EOR (end of row) info | |
208 | Int_t wordinfo2[3]= {1,65593}; //vector with word info for anode info | |
209 | ||
210 | /* for time bin info: word n bits meaning | |
211 | 0 3 next info is timebin | |
212 | 8 3 next word is 8 bit long | |
213 | tb value 8 timebin value | |
214 | n (2->7) 3 next info is n bit long | |
215 | signal n signal value | |
216 | ||
217 | for anode info: 1 3 next 18 bits are for EOR | |
218 | increments the anode value | |
219 | ||
220 | EOR 18 error codes + other info | |
221 | */ | |
222 | ||
2e9f335b | 223 | if(ndigits){ |
9f992f70 | 224 | if (fVerbose==2) |
225 | ftxt.open("SDDdigits.txt",ios::app); | |
2e9f335b | 226 | for (Int_t digit=0;digit<ndigits;digit++) { |
227 | digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit); | |
ecee53fc | 228 | iz=digs->GetCoord1(); // Anode |
229 | ix=digs->GetCoord2(); // Time | |
7f1a504b | 230 | is=digs->GetCompressedSignal(); // ADC Signal |
a97b3678 | 231 | digarr[iz][ix]=is; |
14dceddf | 232 | if (fVerbose==2) |
9f992f70 | 233 | ftxt<<"DDL:"<<ddl<<" MID:"<<modR<<" An:"<<iz<<" T:"<<ix<<" A:"<<is<<endl; |
0421c3d1 | 234 | if (is>255){Error("GetDigitsSDD", "bits words is needed)!!!");} |
a97b3678 | 235 | } |
2e9f335b | 236 | |
a97b3678 | 237 | for(Int_t anode=0;anode<512;anode++){ |
14dceddf | 238 | if(flag){ |
a97b3678 | 239 | last = first+diff-1; |
240 | AliBitPacking::PackWord(word2,baseWord,first,last); | |
241 | flag = kFALSE; | |
242 | first = last+1; | |
243 | diff=0; | |
244 | } | |
a97b3678 | 245 | if(anode == 256){ |
246 | last = 0; | |
247 | first = 0; | |
248 | flag = kFALSE; | |
249 | diff = 0; | |
250 | word2=0; | |
a97b3678 | 251 | } |
252 | ||
253 | for(Int_t tb=0;tb<256;tb++){ | |
254 | if(digarr[anode][tb]!=0){ | |
255 | if(flag){ | |
256 | last = first+diff-1; | |
257 | AliBitPacking::PackWord(word2,baseWord,first,last); | |
258 | flag = kFALSE; | |
259 | first = last+1; | |
260 | diff=0; | |
261 | } | |
262 | wordinfo1[1] = tb; | |
263 | //non lossy compression as it is done in Carlos | |
264 | //(data are already 10to8bit compressed by AMBRA | |
265 | ||
266 | /* if value < 8 value = value - (1 << 2) (word is 2 bit long) | |
267 | if value < 16 value = value - (1 << 3) (word is 3 bit long) | |
268 | if value < 32 value = value - (1 << 4) (word is 4 bit long) | |
269 | if value < 64 value = value - (1 << 5) (word is 5 bit long) | |
270 | if value <128 value = value - (1 << 6) (word is 6 bit long) | |
271 | if value >=128value = value - (1 << 7) (word is 7 bit long) | |
272 | ||
273 | */ | |
ad7f2bfa | 274 | //if(digarr[anode][tb]<4) continue; // not write <4 cnts above tL |
a97b3678 | 275 | if(digarr[anode][tb]<8){ |
276 | bitinfo1[3] = 2; | |
277 | wordinfo1[2] = 2; | |
278 | wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]); | |
279 | } | |
280 | if(digarr[anode][tb]>=8 && digarr[anode][tb]<16){ | |
281 | bitinfo1[3] = 3; | |
282 | wordinfo1[2] = 3; | |
283 | wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]); | |
284 | } | |
285 | if(digarr[anode][tb]>=16 && digarr[anode][tb]<32){ | |
286 | bitinfo1[3] = 4; | |
287 | wordinfo1[2] = 4; | |
288 | wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]); | |
289 | } | |
290 | if(digarr[anode][tb]>=32 && digarr[anode][tb]<64){ | |
291 | bitinfo1[3] = 5; | |
292 | wordinfo1[2] = 5; | |
293 | wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]); | |
294 | } | |
295 | if(digarr[anode][tb]>=64 && digarr[anode][tb]<128){ | |
296 | bitinfo1[3] = 6; | |
297 | wordinfo1[2] = 6; | |
298 | wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]); | |
299 | } | |
300 | if(digarr[anode][tb]>=128){ | |
301 | bitinfo1[3] = 7; | |
302 | wordinfo1[2] = 7; | |
303 | wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]); | |
304 | } | |
305 | ||
306 | for(Int_t ie=0;ie<4;ie++){ | |
307 | ||
308 | if(flag){ | |
309 | last = first+diff-1; | |
310 | AliBitPacking::PackWord(word2,baseWord,first,last); | |
311 | flag = kFALSE; | |
312 | first = last+1; | |
313 | diff=0; | |
314 | } | |
315 | last = first+bitinfo1[ie]-1; | |
316 | if(first < 30 && last < 30){ | |
317 | AliBitPacking::PackWord(wordinfo1[ie],baseWord,first,last); | |
318 | first = last+1; | |
319 | } | |
320 | else{ | |
321 | if(first<=29){ | |
322 | UInt_t w = AliBitPacking::UnpackWord(wordinfo1[ie],0,29-first); | |
323 | AliBitPacking::PackWord(w,baseWord,first,29); | |
324 | Int_t lb = 29-first+1; | |
325 | diff = bitinfo1[ie]-lb; | |
326 | word2 = AliBitPacking::UnpackWord(wordinfo1[ie],lb,lb+diff-1); | |
327 | flag = kTRUE; | |
328 | if(anode<256) word = 2;//channel 0 of carlos | |
329 | else word = 3; //channel 1 of carlos | |
330 | AliBitPacking::PackWord(word,baseWord,30,31); | |
331 | fIndex++; | |
332 | buf[fIndex]=baseWord; | |
333 | first=0; | |
334 | last = 0; | |
335 | baseWord=0; | |
336 | word = 0; | |
337 | } | |
338 | else{ | |
339 | word2 = wordinfo1[ie]; | |
340 | diff = bitinfo1[ie]; | |
341 | flag = kTRUE; | |
342 | if(anode<256) word = 2; //channel 0 of carlos | |
343 | else word = 3; //channel 1 of carlos | |
344 | AliBitPacking::PackWord(word,baseWord,30,31); | |
345 | fIndex++; | |
346 | buf[fIndex]=baseWord; | |
347 | first=0; | |
348 | last=0; | |
349 | baseWord=0; | |
350 | word = 0; | |
351 | } | |
352 | } | |
353 | } | |
354 | ||
355 | }//END IF | |
356 | ||
357 | }//end loop on tb | |
358 | ||
359 | for(Int_t i=0;i<2;i++){ | |
360 | if(flag){ | |
361 | last = first+diff-1; | |
362 | AliBitPacking::PackWord(word2,baseWord,first,last); | |
363 | flag = kFALSE; | |
364 | first = last+1; | |
365 | diff=0; | |
366 | } | |
367 | ||
368 | word = wordinfo2[i]; | |
369 | nbit = bitinfo2[i]; | |
370 | last = first+nbit-1; | |
371 | if(first < 30 && last < 30){ | |
372 | AliBitPacking::PackWord(word,baseWord,first,last); //3 bit code =1 -> next 18 bits for EOR | |
373 | first = last+1; | |
374 | } | |
375 | ||
376 | else{ | |
377 | if(first<=29){ | |
378 | UInt_t w = AliBitPacking::UnpackWord(word,0,29-first); | |
379 | AliBitPacking::PackWord(w,baseWord,first,29); | |
380 | Int_t lb = 29-first+1; | |
381 | diff = nbit-lb; | |
382 | word2 = AliBitPacking::UnpackWord(word,lb,lb+diff-1); | |
383 | flag = kTRUE; | |
384 | if(anode<256) word = 2; | |
385 | else word = 3; | |
386 | AliBitPacking::PackWord(word,baseWord,30,31); | |
387 | fIndex++; | |
388 | buf[fIndex]=baseWord; | |
389 | first=0; | |
390 | last = 0; | |
391 | baseWord=0; | |
392 | if(anode==255){ | |
393 | flag=kFALSE; | |
394 | word2=0; | |
395 | } | |
396 | } | |
397 | else{ | |
398 | word2 = word; | |
399 | diff = nbit; | |
400 | flag = kTRUE; | |
401 | if(anode<256) word = 2; | |
402 | else word = 3; | |
403 | AliBitPacking::PackWord(word,baseWord,30,31); | |
404 | fIndex++; | |
405 | buf[fIndex]=baseWord; | |
406 | first=0; | |
407 | last=0; | |
408 | baseWord=0; | |
409 | if(anode==255){ | |
410 | flag=kFALSE; | |
411 | word2=0; | |
412 | } | |
413 | } | |
414 | } | |
415 | } | |
416 | } //end for | |
417 | ||
418 | } | |
9f992f70 | 419 | if(fVerbose==2) |
420 | ftxt.close(); | |
2e9f335b | 421 | return; |
422 | }//end GetDigitsSDD | |
423 | ||
424 | //////////////////////////////////////////////////////////////////////////////////////// | |
425 | //PIXEL | |
426 | // | |
427 | ||
ad7f2bfa | 428 | void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod,Int_t ddl, UInt_t *buf, AliITSFOSignalsSPD* foSignals){ |
9f992f70 | 429 | //This method packs the SPD digits in a proper 32 structure |
430 | //Since data is zero suppressed,the coordinates for the chip having zero digits | |
431 | //doesn't get listed in the galice.root file. However the SPD format requires | |
432 | //the empty chip to be written with chip header and chip trailer. | |
3f917533 | 433 | |
434 | Int_t chipLow = AliITSRawStreamSPD::GetOnlineChipFromOffline(mod,0); | |
435 | Int_t chipHigh = AliITSRawStreamSPD::GetOnlineChipFromOffline(mod,159); | |
a1317fda | 436 | |
3f917533 | 437 | if (chipLow>chipHigh) {chipLow -= 4; chipHigh += 4;} |
ad7f2bfa | 438 | UInt_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(mod); |
3f917533 | 439 | UInt_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(mod); |
440 | ||
441 | // create int map to later hold all digits sorted | |
442 | AliITSIntMap* digMap = new AliITSIntMap(); | |
443 | ||
0b3c7dfc | 444 | UInt_t baseWord=0; |
ad7f2bfa | 445 | |
2e9f335b | 446 | Int_t ndigits = ITSdigits->GetEntries(); //number of digits in the current module |
447 | //cout<<" Number of digits in the current module:"<<ndigits<<" module:"<<mod<<endl; | |
3f917533 | 448 | |
ad7f2bfa | 449 | // _______________________________________________________________________ |
450 | // Preprocess the digits - sort them in integer map (Henrik Tydesjo) | |
451 | // Needed to have exact same order as in real raw data | |
2e9f335b | 452 | AliITSdigit *digs; |
ad7f2bfa | 453 | ofstream ftxt; |
454 | if (ndigits) { | |
2e9f335b | 455 | //loop over digits |
ad7f2bfa | 456 | if (fVerbose==2) ftxt.open("SPDdigits.txt",ios::app); |
457 | for (Int_t digit=0; digit<ndigits; digit++) { | |
458 | digs = (AliITSdigit*) ITSdigits->UncheckedAt(digit); | |
2e9f335b | 459 | /*--------------------------------------------------------------------------- |
460 | * Each module contains 5 read out chips of 256 rows and 32 columns. | |
3f917533 | 461 | * So, the cell number in Z direction varies from 0 to 159. |
2e9f335b | 462 | * ---------------------------------------------------------------------*/ |
3f917533 | 463 | Int_t iz=digs->GetCoord1(); // Cell number in Z direction |
464 | Int_t ix=digs->GetCoord2(); // Cell number in X direction | |
465 | ||
ad7f2bfa | 466 | if(fVerbose==2) ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl; |
467 | UInt_t dummyDDL, dummyHS, chip, col, row; | |
3f917533 | 468 | AliITSRawStreamSPD::OfflineToOnline(mod,iz,ix,dummyDDL,dummyHS,chip,col,row); |
469 | ||
470 | // insert digit into map... | |
471 | // (reverse order of cols and rows as in real raw data) | |
a1317fda | 472 | digMap->Insert(chip*256*32+(31-col)*256+(255-row),row); |
3f917533 | 473 | } |
474 | } | |
475 | ||
ad7f2bfa | 476 | // _______________________________________________________________________ |
477 | // Procedure for writing raw data (Henrik Tydesjo) | |
478 | // Reimplemented because of unreadability (5 Mar 2009) | |
479 | // Now also with fast-or signals | |
480 | Int_t previousChip = chipLow-1; | |
481 | Int_t chip = chipLow-1; | |
482 | UInt_t chipHitCount = 0; | |
483 | ||
484 | ||
3f917533 | 485 | UInt_t nrHits = digMap->GetNrEntries(); |
ad7f2bfa | 486 | for (UInt_t nHit=0; nHit<nrHits; nHit++) { |
487 | ||
488 | Int_t key = digMap->GetKeyIndex(nHit); | |
489 | chip = key/(256*32); | |
490 | Int_t col = 31 - (key%(256*32))/256; | |
491 | Int_t row = digMap->GetValIndex(nHit); | |
492 | ||
493 | // add trailer for previous chip (if there was one...) | |
494 | if (chip>previousChip && previousChip>chipLow-1) { | |
495 | WriteChipTrailer(buf, chipHitCount, foSignals->GetSignal(eq,hs,previousChip), baseWord); | |
496 | } | |
497 | ||
498 | // add headers/trailers for chips without hits (if any) | |
499 | for (Int_t ch=previousChip+1; ch<chip; ch++) { | |
500 | WriteChipHeader(ch, hs, baseWord); | |
501 | WriteChipTrailer(buf, 0, foSignals->GetSignal(eq,hs,ch), baseWord); | |
502 | } | |
503 | ||
504 | // if new chip, add header | |
505 | if (chip>previousChip) { | |
506 | WriteChipHeader(chip, hs, baseWord); | |
507 | chipHitCount = 0; | |
508 | previousChip = chip; | |
509 | } | |
510 | ||
511 | chipHitCount++; | |
512 | ||
513 | // add pixel hit | |
514 | WriteHit(buf,row,col,baseWord); | |
515 | ||
516 | } | |
517 | ||
518 | // add trailer for last chip (if there was one...) | |
519 | if (chip>chipLow-1) { | |
520 | WriteChipTrailer(buf, chipHitCount, foSignals->GetSignal(eq,hs,chip), baseWord); | |
521 | } | |
522 | ||
523 | // add REMAINING headers/trailers for chips without hits (if any) | |
524 | for (Int_t ch=chip+1; ch<=chipHigh; ch++) { | |
525 | WriteChipHeader(ch, hs, baseWord); | |
526 | WriteChipTrailer(buf, 0, foSignals->GetSignal(eq,hs,ch), baseWord); | |
527 | } | |
528 | // _______________________________________________________________________ | |
529 | ||
3f917533 | 530 | |
531 | delete digMap; | |
532 | ||
9f992f70 | 533 | if(fVerbose==2) |
534 | ftxt.close(); | |
2e9f335b | 535 | return; |
536 | }//end GetDigitsSPD | |
537 | ||
2e9f335b | 538 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
539 | ||
ad7f2bfa | 540 | Int_t AliITSDDLRawData::RawDataSPD(TBranch* branch, AliITSFOSignalsSPD* foSignals){ |
a79660fb | 541 | //This method creates the Raw data files for SPD detectors |
a79660fb | 542 | const Int_t kSize=21000; //256*32*5=40960 max number of digits per module |
0b3c7dfc | 543 | UInt_t buf[kSize]; //One buffer cell can contain 2 digits |
2e9f335b | 544 | fIndex=-1; |
2e9f335b | 545 | |
0421c3d1 | 546 | TClonesArray*& digits = * (TClonesArray**) branch->GetAddress(); |
2c4e6a6a | 547 | TString fileName; |
08f92f14 | 548 | AliFstream* outfile; // logical name of the output file |
f7ee745b | 549 | AliRawDataHeaderSim header; |
0421c3d1 | 550 | |
551 | //loop over DDLs | |
8f02666b | 552 | for(Int_t ddl=0;ddl<AliDAQ::NumberOfDdls("ITSSPD");ddl++){ |
2c4e6a6a | 553 | fileName.Form("%s",AliDAQ::DdlFileName("ITSSPD",ddl)); //The name of the output file. |
554 | outfile = new AliFstream(fileName.Data()); | |
0421c3d1 | 555 | //write Dummy DATA HEADER |
08f92f14 | 556 | UInt_t dataHeaderPosition=outfile->Tellp(); |
557 | outfile->WriteBuffer((char*)(&header),sizeof(header)); | |
2e9f335b | 558 | //Loops over Modules of a particular DDL |
0421c3d1 | 559 | for (Int_t mod=0; mod<AliITSRawStreamSPD::kModulesPerDDL; mod++){ |
8f02666b | 560 | Int_t moduleNumber = AliITSRawStreamSPD::GetModuleNumber(ddl, mod); |
0421c3d1 | 561 | digits->Clear(); |
562 | branch->GetEvent(moduleNumber); | |
2e9f335b | 563 | //For each Module, buf contains the array of data words in Binary format |
564 | //fIndex gives the number of 32 bits words in the buffer for each module | |
ad7f2bfa | 565 | GetDigitsSPD(digits, moduleNumber, ddl, buf, foSignals); |
08f92f14 | 566 | outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t))); |
2e9f335b | 567 | for(Int_t i=0;i<(fIndex+1);i++){ |
568 | buf[i]=0; | |
569 | }//end for | |
570 | fIndex=-1; | |
571 | }//end for | |
572 | ||
0421c3d1 | 573 | //Write REAL DATA HEADER |
08f92f14 | 574 | UInt_t currentFilePosition=outfile->Tellp(); |
575 | outfile->Seekp(dataHeaderPosition); | |
0421c3d1 | 576 | header.fSize=currentFilePosition-dataHeaderPosition; |
08f92f14 | 577 | outfile->WriteBuffer((char*)(&header),sizeof(header)); |
578 | delete outfile; | |
2e9f335b | 579 | }//end for |
0421c3d1 | 580 | |
2e9f335b | 581 | return 0; |
582 | } | |
583 | ||
584 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
585 | ||
0421c3d1 | 586 | Int_t AliITSDDLRawData::RawDataSSD(TBranch* branch){ |
a97b3678 | 587 | |
532a132e | 588 | //This method creates the Raw data files for SSD detectors |
a79660fb | 589 | const Int_t kSize=1536;//768*2 Number of stripe * number of sides(N and P) |
0b3c7dfc | 590 | UInt_t buf[kSize]; |
2e9f335b | 591 | fIndex=-1; |
0421c3d1 | 592 | |
593 | TClonesArray*& digits = * (TClonesArray**) branch->GetAddress(); | |
2c4e6a6a | 594 | TString fileName; |
08f92f14 | 595 | AliFstream* outfile; // logical name of the output file |
f7ee745b | 596 | AliRawDataHeaderSim header; |
2e9f335b | 597 | |
0421c3d1 | 598 | //loop over DDLs |
362c9d61 | 599 | for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSSD");i++){ |
2c4e6a6a | 600 | fileName.Form("%s",AliDAQ::DdlFileName("ITSSSD",i)); //The name of the output file. |
601 | outfile = new AliFstream(fileName.Data()); | |
0421c3d1 | 602 | //write Dummy DATA HEADER |
08f92f14 | 603 | UInt_t dataHeaderPosition=outfile->Tellp(); |
604 | outfile->WriteBuffer((char*)(&header),sizeof(header)); | |
2e9f335b | 605 | |
606 | //Loops over Modules of a particular DDL | |
0421c3d1 | 607 | for (Int_t mod=0; mod<AliITSRawStreamSSD::kModulesPerDDL; mod++){ |
608 | Int_t moduleNumber = AliITSRawStreamSSD::GetModuleNumber(i, mod); | |
609 | if(moduleNumber!=-1){ | |
610 | digits->Clear(); | |
611 | branch->GetEvent(moduleNumber); | |
2e9f335b | 612 | //For each Module, buf contains the array of data words in Binary format |
613 | //fIndex gives the number of 32 bits words in the buffer for each module | |
0421c3d1 | 614 | GetDigitsSSD(digits,mod,moduleNumber,i,buf); |
08f92f14 | 615 | outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t))); |
2e9f335b | 616 | fIndex=-1; |
617 | }//end if | |
618 | }//end for | |
0421c3d1 | 619 | |
620 | //Write REAL DATA HEADER | |
08f92f14 | 621 | UInt_t currentFilePosition=outfile->Tellp(); |
622 | outfile->Seekp(dataHeaderPosition); | |
0421c3d1 | 623 | header.fSize=currentFilePosition-dataHeaderPosition; |
624 | header.SetAttribute(0); // valid data | |
08f92f14 | 625 | outfile->WriteBuffer((char*)(&header),sizeof(header)); |
626 | delete outfile; | |
2e9f335b | 627 | }//end for |
0421c3d1 | 628 | |
2e9f335b | 629 | return 0; |
630 | } | |
631 | ||
632 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
633 | ||
979b5a5f | 634 | Int_t AliITSDDLRawData::RawDataSDD(TBranch* branch, AliITSDDLModuleMapSDD* ddlsdd){ |
a79660fb | 635 | //This method creates the Raw data files for SDD detectors |
a79660fb | 636 | const Int_t kSize=131072; //256*512 |
0b3c7dfc | 637 | UInt_t buf[kSize]; |
2e9f335b | 638 | fIndex=-1; |
2e9f335b | 639 | |
0421c3d1 | 640 | TClonesArray*& digits = * (TClonesArray**) branch->GetAddress(); |
2c4e6a6a | 641 | TString fileName; |
08f92f14 | 642 | AliFstream* outfile; // logical name of the output file |
f7ee745b | 643 | AliRawDataHeaderSim header; |
d9ed1779 | 644 | |
645 | if(fSDDRawFormat!=0){ | |
646 | for(Int_t ibit=0; ibit<8; ibit++) header.SetAttribute(ibit); | |
647 | }else{ | |
648 | for(Int_t ibit=0; ibit<5; ibit++) header.SetAttribute(ibit); | |
649 | for(Int_t ibit=5; ibit<8; ibit++) header.ResetAttribute(ibit); | |
650 | } | |
5dfa68c5 | 651 | UInt_t skippedword, carlosFooterWord,fifoFooterWord,jitterWord; |
652 | Bool_t retcode; | |
653 | retcode = AliBitPacking::PackWord(0x3FFFFFFF,carlosFooterWord,0,31); | |
654 | retcode = AliBitPacking::PackWord(0x3F1F1F1F,fifoFooterWord,0,31); | |
d9ed1779 | 655 | if(fSDDRawFormat!=0) retcode = AliBitPacking::PackWord(0x7F000000,jitterWord,0,31); |
de075dae | 656 | else retcode = AliBitPacking::PackWord(0x80000000,jitterWord,0,31); |
657 | ||
0421c3d1 | 658 | //loop over DDLs |
362c9d61 | 659 | for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSDD");i++){ |
2c4e6a6a | 660 | fileName.Form("%s",AliDAQ::DdlFileName("ITSSDD",i)); //The name of the output file. |
661 | outfile = new AliFstream(fileName.Data()); | |
0421c3d1 | 662 | //write Dummy DATA HEADER |
08f92f14 | 663 | UInt_t dataHeaderPosition=outfile->Tellp(); |
664 | outfile->WriteBuffer((char*)(&header),sizeof(header)); | |
0421c3d1 | 665 | |
5dfa68c5 | 666 | |
8345a1cf | 667 | //first 1 "dummy" word to be skipped |
d9ed1779 | 668 | if(fSDDRawFormat!=0){ |
ad1b4ad1 | 669 | retcode = AliBitPacking::PackWord(0xFFFFFFFF,skippedword,0,31); |
670 | outfile->WriteBuffer((char*)(&skippedword),sizeof(skippedword)); | |
671 | } | |
8345a1cf | 672 | |
2e9f335b | 673 | //Loops over Modules of a particular DDL |
0421c3d1 | 674 | for (Int_t mod=0; mod<AliITSRawStreamSDD::kModulesPerDDL; mod++){ |
979b5a5f | 675 | Int_t moduleNumber = ddlsdd->GetModuleNumber(i, mod); |
0421c3d1 | 676 | if(moduleNumber!=-1){ |
677 | digits->Clear(); | |
678 | branch->GetEvent(moduleNumber); | |
a97b3678 | 679 | |
2e9f335b | 680 | //For each Module, buf contains the array of data words in Binary format |
681 | //fIndex gives the number of 32 bits words in the buffer for each module | |
a79660fb | 682 | // cout<<"MODULE NUMBER:"<<mapSDD[i][mod]<<endl; |
d9ed1779 | 683 | if(fSDDRawFormat==0){ |
ad1b4ad1 | 684 | GetDigitsSDDCompressed(digits,mod,buf); |
685 | outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t))); | |
686 | }else{ | |
687 | GetDigitsSDD(digits,mod,moduleNumber,i,buf); | |
688 | outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t))); | |
689 | for(Int_t iw=0;iw<3;iw++) outfile->WriteBuffer((char*)(&carlosFooterWord),sizeof(carlosFooterWord)); | |
690 | } | |
2e9f335b | 691 | fIndex=-1; |
692 | }//end if | |
693 | }//end for | |
5dfa68c5 | 694 | // 12 words with FIFO footers (=4 FIFO x 3 3F1F1F1F words per DDL) |
d9ed1779 | 695 | if(fSDDRawFormat!=0){ |
ad1b4ad1 | 696 | for(Int_t iw=0;iw<12;iw++) outfile->WriteBuffer((char*)(&fifoFooterWord),sizeof(fifoFooterWord)); |
ad1b4ad1 | 697 | } |
de075dae | 698 | outfile->WriteBuffer((char*)(&jitterWord),sizeof(jitterWord)); |
0421c3d1 | 699 | //Write REAL DATA HEADER |
08f92f14 | 700 | UInt_t currentFilePosition=outfile->Tellp(); |
701 | outfile->Seekp(dataHeaderPosition); | |
0421c3d1 | 702 | header.fSize=currentFilePosition-dataHeaderPosition; |
703 | header.SetAttribute(0); // valid data | |
08f92f14 | 704 | outfile->WriteBuffer((char*)(&header),sizeof(header)); |
705 | delete outfile; | |
2e9f335b | 706 | }//end for |
0421c3d1 | 707 | |
2e9f335b | 708 | return 0; |
709 | } | |
710 | ||
711 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
712 | ||
a643f6be | 713 | void AliITSDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t halfStave,UInt_t &BaseWord){ |
a79660fb | 714 | //This method writes a chip header |
a643f6be | 715 | //cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<halfStave<<endl; |
2e9f335b | 716 | BaseWord=0; |
a643f6be | 717 | AliBitPacking::PackWord(ChipAddr,BaseWord,16,19); |
718 | // At the moment the event count is always 0 (bits 20-26) | |
719 | AliBitPacking::PackWord(0,BaseWord,20,26); | |
720 | AliBitPacking::PackWord(halfStave,BaseWord,27,29); | |
721 | AliBitPacking::PackWord(0x1,BaseWord,30,31); | |
2e9f335b | 722 | return; |
723 | }//end WriteChipHeader | |
724 | ||
725 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
726 | ||
ad7f2bfa | 727 | void AliITSDDLRawData::WriteChipTrailer(UInt_t *buf, Int_t ChipHitCount, Bool_t foBit, UInt_t &BaseWord){ |
a79660fb | 728 | //This method writes a chip trailer |
2e9f335b | 729 | //pixel fill word |
730 | if((ChipHitCount%2)!=0){ | |
a643f6be | 731 | AliBitPacking::PackWord(0xC000,BaseWord,16,31); |
2e9f335b | 732 | } |
ad7f2bfa | 733 | AliBitPacking::PackWord(ChipHitCount,BaseWord,0,11); |
734 | AliBitPacking::PackWord(0x0,BaseWord,12,12); | |
735 | AliBitPacking::PackWord(foBit,BaseWord,13,13); | |
a643f6be | 736 | AliBitPacking::PackWord(0x0,BaseWord,14,15); |
2e9f335b | 737 | fIndex++; |
738 | buf[fIndex]=BaseWord; | |
739 | BaseWord=0; | |
740 | return; | |
741 | }//end WriteChipTrailer | |
742 | ||
743 | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// | |
744 | ||
0b3c7dfc | 745 | void AliITSDDLRawData::WriteHit(UInt_t *buf,Int_t RowAddr,Int_t HitAddr,UInt_t &BaseWord){ |
a79660fb | 746 | //This method writs an hit |
2e9f335b | 747 | if(!BaseWord){ |
113c12f1 | 748 | AliBitPacking::PackWord(HitAddr,BaseWord,16,20); |
749 | AliBitPacking::PackWord(RowAddr,BaseWord,21,28); | |
750 | AliBitPacking::PackWord(2,BaseWord,30,31); | |
a643f6be | 751 | }//end if |
752 | else{ | |
753 | AliBitPacking::PackWord(HitAddr,BaseWord,0,4); | |
754 | AliBitPacking::PackWord(RowAddr,BaseWord,5,12); | |
755 | AliBitPacking::PackWord(2,BaseWord,14,15); | |
2e9f335b | 756 | fIndex++; |
757 | buf[fIndex]=BaseWord; | |
758 | BaseWord=0; | |
759 | }//end else | |
760 | return; | |
761 | }//end WriteHit | |
f957a032 | 762 |