new classes for raw data processing (T. Kuhr)
[u/mrichter/AliRoot.git] / ITS / AliITSDDLRawData.cxx
CommitLineData
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>
0f0615a3 26#include "Riostream.h"
2e9f335b 27#include <TClonesArray.h>
28#include <TTree.h>
0f0615a3 29#include "TMath.h"
2e9f335b 30#include <AliITS.h>
31#include <AliITSgeom.h>
32#include <AliITSdigit.h>
33#include "AliITSDDLRawData.h"
34
35ClassImp(AliITSDDLRawData)
36
37////////////////////////////////////////////////////////////////////////////////////////
38AliITSDDLRawData::AliITSDDLRawData(){
a79660fb 39 //Default constructor
2e9f335b 40 fIndex=-1;
41 fHalfStaveModule=-1;
9f992f70 42 fVerbose=0;
2e9f335b 43}
44
45////////////////////////////////////////////////////////////////////////////////////////
46
47AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source){
a79660fb 48 //Copy Constructor
2e9f335b 49 this->fIndex=source.fIndex;
50 this->fHalfStaveModule=source.fHalfStaveModule;
9f992f70 51 this->fVerbose=source.fVerbose;
2e9f335b 52 return;
53}
54
55////////////////////////////////////////////////////////////////////////////////////////
56
57AliITSDDLRawData& AliITSDDLRawData::operator=(const AliITSDDLRawData &source){
58 //Assigment operator
59 this->fIndex=source.fIndex;
60 this->fHalfStaveModule=source.fHalfStaveModule;
9f992f70 61 this->fVerbose=source.fVerbose;
2e9f335b 62 return *this;
63}
64
65////////////////////////////////////////////////////////////////////////////////////////
66//STRIP
67//
68
9f992f70 69void AliITSDDLRawData::GetDigitsSSD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,ULong_t *buf){
a79660fb 70 //This method packs the SSD digits in a proper 32 bits structure
2e9f335b 71 Int_t ix;
72 Int_t iz;
73 Int_t is;
a79660fb 74 ULong_t word;
75 ULong_t baseWord;
2e9f335b 76 Int_t ndigits = ITSdigits->GetEntries();
77 AliITSdigit *digs;
9f992f70 78 ofstream ftxt;
2e9f335b 79 if(ndigits){
9f992f70 80 if (fVerbose==2){
81 ftxt.open("SSDdigits.txt",ios::app);
82 }
2e9f335b 83 for (Int_t digit=0;digit<ndigits;digit++) {
84 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
85 iz=digs->fCoord1; // If iz==0, N side and if iz=1 P side
86 ix=digs->fCoord2; // Strip Numbar
87 is=digs->fSignal; // ADC Signal
88 // cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
9f992f70 89 if (fVerbose==2)
90 ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl;
a79660fb 91 baseWord=0;
92 word=is-1;
93 PackWord(baseWord,word,0,9);//ADC data
94 word=ix;
95 PackWord(baseWord,word,10,19);//Strip Number
96 word=iz;
97 PackWord(baseWord,word,20,20);//ADC Channel ID (N or P side)
98 word=mod;
99 PackWord(baseWord,word,21,31);//ADC module ID
2e9f335b 100 fIndex++;
a79660fb 101 buf[fIndex]=baseWord;
2e9f335b 102 }//end for
103 }//end if
9f992f70 104 if (fVerbose==2)
105 ftxt.close();
2e9f335b 106 return;
107}//end GetDigitsSSD
108
109////////////////////////////////////////////////////////////////////////////////////////
110//Silicon Drift Detector
111//
112
9f992f70 113void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,ULong_t *buf){
a79660fb 114 //This method packs the SSD digits in a proper 32 bits structure
2e9f335b 115 Int_t ix;
116 Int_t iz;
117 Int_t is;
a79660fb 118 ULong_t word;
119 ULong_t baseWord;
2e9f335b 120 Int_t ndigits = ITSdigits->GetEntries();
121 AliITSdigit *digs;
9f992f70 122 ofstream ftxt;
2e9f335b 123 if(ndigits){
124 //cout<<"Mudule "<<mod<<" number of digits "<<ndigits<<endl;
9f992f70 125 if (fVerbose==2)
126 ftxt.open("SDDdigits.txt",ios::app);
2e9f335b 127 for (Int_t digit=0;digit<ndigits;digit++) {
128 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
129 iz=digs->fCoord1; // Anode
130 ix=digs->fCoord2; // Time
131 is=digs->fSignal; // ADC Signal
9f992f70 132 if (fVerbose==2)
133 ftxt<<"DDL:"<<ddl<<" MID:"<<modR<<" An:"<<iz<<" T:"<<ix<<" A:"<<is<<endl;
2e9f335b 134 // cout<<"Amplitude value:"<<is<<" Time Bucket:"<<ix<<" Anode:"<<iz<<endl;
135 if (is>255){cout<<"WARNING (!) bits words is needed)!!!\n";}
a79660fb 136 baseWord=0;
2e9f335b 137 /*
138 //10 bits words for amplitude value
a79660fb 139 word=is;
140 PackWord(baseWord,word,0,9);//ADC data
141 word=ix;
142 PackWord(baseWord,word,10,17);//Time bucket
143 word=iz;
144 PackWord(baseWord,word,18,26);//Anode Number
145 word=mod;
146 PackWord(baseWord,word,27,31);//Module number
2e9f335b 147 */
148
149 //8bits words for amplitude value
a79660fb 150 word=is;
151 PackWord(baseWord,word,0,7);//ADC data
152 word=ix;
153 PackWord(baseWord,word,8,15);//Time bucket
154 word=iz;
155 PackWord(baseWord,word,16,24);//Anode Number
156 word=mod;
157 PackWord(baseWord,word,25,31);//Module number
2e9f335b 158
159 fIndex++;
a79660fb 160 buf[fIndex]=baseWord;
2e9f335b 161 }//end for
162 }//end if
9f992f70 163 if(fVerbose==2)
164 ftxt.close();
2e9f335b 165 return;
166}//end GetDigitsSDD
167
168////////////////////////////////////////////////////////////////////////////////////////
169//PIXEL
170//
171
9f992f70 172void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod,Int_t ddl, ULong_t *buf){
173 //This method packs the SPD digits in a proper 32 structure
174 //Since data is zero suppressed,the coordinates for the chip having zero digits
175 //doesn't get listed in the galice.root file. However the SPD format requires
176 //the empty chip to be written with chip header and chip trailer.
2e9f335b 177 Int_t ix;
178 Int_t iz;
a79660fb 179 Int_t chipNo=0;
180 ULong_t baseWord=0;
181 ULong_t hitRow=0;
182 Int_t chipHitCount=0; //Number of Hit in the current chip
183 Int_t previousChip=-1; //Previuos chip respect to the actual aone
2e9f335b 184 Int_t ndigits = ITSdigits->GetEntries(); //number of digits in the current module
185 //cout<<" Number of digits in the current module:"<<ndigits<<" module:"<<mod<<endl;
186 AliITSdigit *digs;
187 fHalfStaveModule++; //It's a private variable used to distinguish between the firs
188 //and the second module of an Half Stave Module
9f992f70 189 ofstream ftxt;
2e9f335b 190 if(ndigits){
191 //loop over digits
9f992f70 192 if (fVerbose==2)
193 ftxt.open("SPDdigits.txt",ios::app);
2e9f335b 194 for (Int_t digit=0;digit<ndigits;digit++){
195 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
196 /*---------------------------------------------------------------------------
197 * Each module contains 5 read out chips of 256 rows and 32 columns.
9f992f70 198 * So, the cell number in Z direction varies from 0 to 159. Therefore,
2e9f335b 199 * to get the chip address (0 to 4), we need to divide column number by 32.
200 * ---------------------------------------------------------------------*/
201 iz=digs->fCoord1; // Cell number in Z direction
202 ix=digs->fCoord2; // Cell number in X direction
a79660fb 203 chipNo=iz/32;
9f992f70 204 if(fVerbose==2)
205 ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl;
a79660fb 206 hitRow=iz-chipNo*32;
2e9f335b 207 if(fHalfStaveModule){
a79660fb 208 chipNo+=5;
2e9f335b 209 fHalfStaveModule=-1;
210 }//end if
a79660fb 211 if(previousChip==-1){
2e9f335b 212 //loop over chip without digits
213 //Even if there aren't digits for a given chip
214 //the chip header and the chip trailer are stored
215 for(Int_t i=0;i<(iz/32);i++){
a79660fb 216 if(chipNo>4)
217 WriteChipHeader(i+5,(mod/2),baseWord);
2e9f335b 218 else
a79660fb 219 WriteChipHeader(i,(mod/2),baseWord);
220 WriteChipTrailer(buf,chipHitCount,baseWord);
9f992f70 221 chipHitCount=0;
2e9f335b 222 }//end for
a79660fb 223 WriteChipHeader(chipNo,(mod/2),baseWord);
224 chipHitCount++;
225 WriteHit(buf,ix,hitRow,baseWord);
9f992f70 226 previousChip=chipNo;
2e9f335b 227 }//end if
228 else{
a79660fb 229 if(previousChip!=chipNo){
9f992f70 230 WriteChipTrailer(buf,chipHitCount,baseWord);
231 chipHitCount=0;
a79660fb 232 for(Int_t i=previousChip+1;i<chipNo;i++){
233 WriteChipHeader(i,(mod/2),baseWord);
234 WriteChipTrailer(buf,0,baseWord);
9f992f70 235 chipHitCount=0;
2e9f335b 236 }//end for
a79660fb 237 WriteChipHeader(chipNo,(mod/2),baseWord);
238 previousChip=chipNo;
2e9f335b 239 }//end if
9f992f70 240 chipHitCount++;
a79660fb 241 WriteHit(buf,ix,hitRow,baseWord);
2e9f335b 242 }//end else
243 }//end for
244 //Even if there aren't digits for a given chip
245 //the chip header and the chip trailer are stored
a79660fb 246 Int_t end=4;
247 if(chipNo>4)end+=5;
248 WriteChipTrailer(buf,chipHitCount,baseWord);
9f992f70 249 chipHitCount=0;
a79660fb 250 for(Int_t i=chipNo+1;i<=end;i++){
251 WriteChipHeader(i,(mod/2),baseWord);
252 WriteChipTrailer(buf,0,baseWord);
9f992f70 253 chipHitCount=0;
2e9f335b 254 }//end for
255 }//end if
256 else{
257 //In this module there aren't digits but
258 //the chip header and chip trailer are store anyway
259 if(fHalfStaveModule){
a79660fb 260 chipNo=5;
2e9f335b 261 fHalfStaveModule=-1;
262 }//end if
263 for(Int_t i=0;i<5;i++){
a79660fb 264 WriteChipHeader(chipNo+i,(mod/2),baseWord);
265 WriteChipTrailer(buf,chipHitCount,baseWord);
9f992f70 266 chipHitCount=0;
2e9f335b 267 }//end for
268 }//end else
9f992f70 269 if(fVerbose==2)
270 ftxt.close();
2e9f335b 271 return;
272}//end GetDigitsSPD
273
274////////////////////////////////////////////////////////////////////////////////////////////////////////////////
275
276void AliITSDDLRawData::PackWord(ULong_t &BaseWord, ULong_t Word, Int_t StartBit, Int_t StopBit){
a79660fb 277 //This method packs a word into the Baseword buffer starting form the "StartBit"
278 //and tacking StopBit-StertBit+1 bits
279 ULong_t dummyWord,offSet;
280 Int_t length;
281 ULong_t sum;
2e9f335b 282 //The BaseWord is being filled with 1 from StartBit to StopBit
a79660fb 283 length=StopBit-StartBit+1;
284 sum=(ULong_t)TMath::Power(2,length)-1;
285 if(Word > sum){
2e9f335b 286 cout<<"WARNING::Word to be filled is not within desired length"<<endl;
287 cout<<"Word:"<<Word<<" Start bit:"<<StartBit<<" Stop Bit:"<<StopBit<<endl;
288 exit(-1);
289 }
a79660fb 290 offSet=sum;
291 offSet<<=StartBit;
292 BaseWord=BaseWord|offSet;
2e9f335b 293 //The Word to be filled is shifted to the position StartBit
294 //and the remaining Left and Right bits are filled with 1
a79660fb 295 sum=(ULong_t)TMath::Power(2,StartBit)-1;
296 dummyWord=0xFFFFFFFF<<length;
297 dummyWord +=Word;
298 dummyWord<<=StartBit;
299 dummyWord+=sum;
300 BaseWord=BaseWord&dummyWord;
2e9f335b 301 return;
302}
303
304/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
305
306void AliITSDDLRawData::UnpackWord(ULong_t PackedWord, Int_t StartBit, Int_t StopBit, ULong_t &Word){
a79660fb 307 //This method unpacks a words of StopBit-StertBit+1 bits starting from "StopBits"
308 ULong_t offSet;
309 Int_t length;
310 length=StopBit-StartBit+1;
311 offSet=(ULong_t)TMath::Power(2,length)-1;
312 offSet<<=StartBit;
313 Word=PackedWord&offSet;
2e9f335b 314 Word>>=StartBit;
315 return;
316}
317
318/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
319
320Int_t AliITSDDLRawData::RawDataSPD(AliITS *ITS,TTree *TD ,Int_t LDCsNumber){
a79660fb 321 //This method creates the Raw data files for SPD detectors
2e9f335b 322 //Silicon Pixel Detector
a79660fb 323 const Int_t kDDLsNumber=20; // Number of DDL in SPD
324 const Int_t kModulesPerDDL=12; // Number of modules in each DDL
2e9f335b 325 //Row ==> DDLs
326 //Column ==> Modules
a79660fb 327 Int_t mapSPD[kDDLsNumber][kModulesPerDDL]={{ 0, 1, 4, 5, 80, 81, 84, 85, 88, 89, 92, 93},
2e9f335b 328 { 2, 3, 6, 7, 82, 83, 86, 87, 90, 91, 94, 95},
329 { 8, 9,12,13, 96, 97,100,101,104,105,108,109},
330 {10,11,14,15, 98, 99,102,103,106,107,110,111},
331 {16,17,20,21,112,113,116,117,120,121,124,125},
332 {18,19,22,23,114,115,118,119,122,123,126,127},
333 {24,25,28,29,128,129,132,133,136,137,140,141},
334 {26,27,30,31,130,131,134,135,138,139,142,143},
335 {32,33,36,37,144,145,148,149,152,153,156,157},
336 {34,35,38,39,146,147,150,151,154,155,158,159},
337 {40,41,44,45,160,161,164,165,168,169,172,173},
338 {42,43,46,47,162,163,166,167,170,171,174,175},
c391f9d9 339 {48,49,52,53,176,177,180,181,184,185,188,189},
2e9f335b 340 {50,51,54,55,178,179,182,183,186,187,190,191},
341 {56,57,60,61,192,193,196,197,200,201,204,205},
342 {58,59,62,63,194,195,198,199,202,203,206,207},
343 {64,65,68,69,208,209,212,213,216,217,220,221},
344 {66,67,70,71,210,211,214,215,218,219,222,223},
345 {72,73,76,77,224,225,228,229,232,233,236,237},
346 {74,75,78,79,226,227,230,231,234,235,238,239}};
a79660fb 347 Int_t ddlsPerFile=kDDLsNumber/LDCsNumber;
348 if(kDDLsNumber%LDCsNumber)ddlsPerFile++;
9f992f70 349 if(fVerbose)
350 cout<<"Number of DDL per File: "<<ddlsPerFile<<endl;
2e9f335b 351 Int_t subd=0;
a79660fb 352 Int_t countDDL=0;
353 Int_t sliceNumber=1;
354 const Int_t kSize=21000; //256*32*5=40960 max number of digits per module
355 ULong_t buf[kSize]; //One buffer cell can contain 2 digits
2e9f335b 356 fIndex=-1;
a79660fb 357 TClonesArray *digitsInITS = ITS->DigitsAddress(subd);
2e9f335b 358
359 Int_t nbytes = 0;
360 char fileName[15];
361
a79660fb 362 ULong_t miniHeaderPosition=0; //variable used to store the position of the Mini Header inside a file
2e9f335b 363 ofstream outfile; // logical name of the output file
a79660fb 364 Int_t flag=0; // 0==> Uncompressed data 1==>Compressed Data
365 Int_t detector=1; // 1==>ITS (Pixel) 2==>ITS (Drift) 3==>ITS (Strip) 0==>TPC ......
366 ULong_t size=0; // size of the data block that follows the mini header
367 Int_t magicWord=0x123456; // Magic word used to distinguish between data and garbage
368 sprintf(fileName,"SPDslice%d",sliceNumber); //The name of the output file. There are as many slides as the number of LDC
30c1018e 369#ifndef __DECCXX
2e9f335b 370 outfile.open(fileName,ios::binary);
30c1018e 371#else
372 outfile.open(fileName);
373#endif
a79660fb 374 ULong_t miniHeader[3];
375 Int_t miniHeaderSize=sizeof(ULong_t)*3;
376 Int_t version=1; //version of the mini header
2e9f335b 377 //loop over DDLs
a79660fb 378 for(Int_t i=0;i<kDDLsNumber;i++){
379 countDDL++;
2e9f335b 380 //write Dummy MINI HEADER
a79660fb 381 miniHeader[0]=size;
382 PackWord(miniHeader[1],magicWord,8,31);
383 PackWord(miniHeader[1],detector,0,7);
384 PackWord(miniHeader[2],i,16,31);
385 PackWord(miniHeader[2],flag,8,15);
386 PackWord(miniHeader[2],version,0,7);
387 miniHeaderPosition=outfile.tellp();
388 outfile.write((char*)(miniHeader),miniHeaderSize);
2e9f335b 389 //Loops over Modules of a particular DDL
a79660fb 390 for (Int_t mod=0; mod<kModulesPerDDL; mod++){
2e9f335b 391 ITS->ResetDigits();
a79660fb 392 nbytes += TD->GetEvent(mapSPD[i][mod]);
2e9f335b 393 //For each Module, buf contains the array of data words in Binary format
394 //fIndex gives the number of 32 bits words in the buffer for each module
9f992f70 395 GetDigitsSPD(digitsInITS,mapSPD[i][mod],i,buf);
2e9f335b 396 outfile.write((char *)buf,((fIndex+1)*sizeof(ULong_t)));
397 for(Int_t i=0;i<(fIndex+1);i++){
398 buf[i]=0;
399 }//end for
400 fIndex=-1;
401 }//end for
402
403 //Write REAL MINI HEADER
a79660fb 404 ULong_t currentFilePosition=outfile.tellp();
405 outfile.seekp(miniHeaderPosition);
406 size=currentFilePosition-miniHeaderPosition-miniHeaderSize;
2e9f335b 407
a79660fb 408 outfile.write((char*)(&size),sizeof(ULong_t));
409 outfile.seekp(currentFilePosition);
410 if(countDDL==ddlsPerFile){
2e9f335b 411 outfile.close();
a79660fb 412 sliceNumber++;
413 sprintf(fileName,"SPDslice%d",sliceNumber);
414 if(i!=(kDDLsNumber-1))
30c1018e 415#ifndef __DECCXX
2e9f335b 416 outfile.open(fileName,ios::binary);
30c1018e 417#else
418 outfile.open(fileName);
419#endif
a79660fb 420 countDDL=0;
2e9f335b 421 }//end if
422 }//end for
423 outfile.close();
424 return 0;
425}
426
427/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
428
429Int_t AliITSDDLRawData::RawDataSSD(AliITS *ITS,TTree *TD ,Int_t LDCsNumber){
a79660fb 430 //This method creates the Raw data files for SSD detectors
2e9f335b 431 //Strip detector
a79660fb 432 const Int_t kDDLsNumber=16; // Number of DDL in SSD
433 const Int_t kModulesPerDDL=109; // Number of modules in each DDL
2e9f335b 434 //DDL from 32 to 47 (16 DDL)
435 //Row ==> DDLs
436 //Column ==> Modules
a79660fb 437 Int_t mapSSD[kDDLsNumber][kModulesPerDDL]={
2e9f335b 438 //104
439 //DDL[32][]=
440 { 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510,
441 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532,
442 1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,
443 1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,
444 1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,
445 2098,2099,2100,2101,2102,2103,2104,2105,2106,2107,2108,2109,
446 2123,2124,2125,2126,2127,2128,2129,2130,2131,2132,2133,2134,
447 2148,2149,2150,2151,2152,2153,2154,2155,2156,2157,2158,2159,
448 2173,2174,2175,2176,2177,2178,2179,2180,2181,2182,2183,2184,-1,-1,-1,-1,-1},
449 //93
450 //DDL[33][]=
c391f9d9 451 { 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554,
452 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
2e9f335b 453 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598,
454 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620,
455 1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,
456 1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,
457 1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,
458 1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,
c391f9d9 459 1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,-1,-1,-1,-1,-1},
2e9f335b 460 //103
461 //DDL[34][]=
462 { 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642,
463 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664,
464 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686,
465 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708,
466 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730,
467 1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,
468 1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,
469 1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,
470 1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,-1,-1,-1,-1,-1,-1},
471 //104
472 //DDL[35][]=
473 { 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
474 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774,
475 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796,
476 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818,
477 1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,
478 1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,
479 1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,
480 1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,
481 1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,-1,-1,-1,-1,-1},
482 //104
483 //DDL[36[]=
484 { 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840,
485 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862,
486 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884,
487 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906,
488 1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,
489 1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,
c391f9d9 490 1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,
2e9f335b 491 1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,
492 1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,-1,-1,-1,-1,-1},
493 //104
494 //DDL[37][]=
495 { 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928,
496 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950,
497 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972,
498 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994,
499 1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,
500 1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,
501 1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,
502 1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,
503 1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,-1,-1,-1,-1,-1},
504 //103
505 //DDL[38][]=
506 {1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,
507 1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,
508 1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,
509 1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,
510 1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,
511 1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,
512 1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,
513 1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,
514 1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,-1,-1,-1,-1,-1,-1},
515 //104
516 //DDL[39][]=
517 {1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,
518 1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,
519 1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,
520 1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,
521 1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,
522 1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,
523 2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,
524 2048,2049,2050,2051,2052,2053,2054,2055,2056,2057,2058,2059,
525 2073,2074,2075,2076,2077,2078,2079,2080,2081,2082,2083,2084,-1,-1,-1,-1,-1},
526 //109
527 //DDL[40][]=
528 { 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521,
529 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543,
530 1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,
531 1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,
532 1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,
533 2110,2111,2112,2113,2114,2115,2116,2117,2118,2119,2120,2121,2122,
534 2135,2136,2137,2138,2139,2140,2141,2142,2143,2144,2145,2146,2147,
535 2160,2161,2162,2163,2164,2165,2166,2167,2168,2169,2170,2171,2172,
536 2185,2186,2187,2188,2189,2190,2191,2192,2193,2194,2195,2196,2197},
537 //109
538 //DDL[41][]=
539 { 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565,
540 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587,
541 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609,
542 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631,
543 1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,
544 1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,
c391f9d9 545 1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,
2e9f335b 546 1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,
547 1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397},
548 //107
549 //DDL[42][]=
550 { 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653,
551 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675,
552 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697,
553 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719,
554 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741,
555 1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,
556 1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,
557 1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,
558 1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,-1,-1},
559 //109
560 //DDL[43][]=
561 { 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763,
562 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785,
563 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807,
564 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829,
565 1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,
566 1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,
567 1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,
c391f9d9 568 1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,
2e9f335b 569 1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622},
570 //109
571 //DDL[44][]=
572 { 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851,
573 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873,
574 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895,
575 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917,
576 1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,
577 1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,
578 1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,
579 1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,
580 1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747},
581 //109
582 //DDL[45][]=
583 {929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939,
584 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961,
585 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983,
586 995, 996, 997, 998, 999,1000,1001,1002,1003,1004,1005,
587 1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,
588 1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,
589 1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,
590 1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,
591 1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872},
592 //109
593 //DDL[46][]=
594 {1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,
595 1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,
596 1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,
597 1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,
598 1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,
599 1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,
600 1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,
601 1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,
602 1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972},
603 //109
604 //DDL[47][]=
605 {1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,
606 1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,
607 1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,
608 1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,
609 1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,
610 2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,
611 2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047,
612 2060,2061,2062,2063,2064,2065,2066,2067,2068,2069,2070,2071,2072,
613 2085,2086,2087,2088,2089,2090,2091,2092,2093,2094,2095,2096,2097} };
614
615
a79660fb 616 Int_t ddlsPerFile=kDDLsNumber/LDCsNumber;
9f992f70 617 if(kDDLsNumber%LDCsNumber)ddlsPerFile++;
618 if(fVerbose)
619 cout<<"Number of DDL per File: "<<ddlsPerFile<<endl;
2e9f335b 620 Int_t subd=2; //SSD
a79660fb 621 Int_t countDDL=0;
622 Int_t sliceNumber=1;
623 const Int_t kSize=1536;//768*2 Number of stripe * number of sides(N and P)
624 ULong_t buf[kSize];
2e9f335b 625 fIndex=-1;
626 Int_t nbytes = 0;
a79660fb 627 TClonesArray *digitsInITS = ITS->DigitsAddress(subd);
2e9f335b 628 char fileName[15];
629
a79660fb 630 ULong_t miniHeaderPosition=0; //variable used to store the position of the Mini Header inside the file
2e9f335b 631 ofstream outfile; // logical name of the output file
a79660fb 632 Int_t flag=0; // 0==> Uncompressed data 1==>Compressed Data
633 Int_t detector=3; // 1==>ITS (Pixel) 2==>ITS (Drift) 3==>ITS (Strip) 0==>TPC ......
634 ULong_t size=0; // size of the data block that follows the mini header
635 Int_t magicWord=0x123456; // Magic word used to distinguish between data and garbage
636 sprintf(fileName,"SSDslice%d",sliceNumber); //The name of the output file. There are as many slides as the number of LDC
30c1018e 637#ifndef __DECCXX
2e9f335b 638 outfile.open(fileName,ios::binary);
30c1018e 639#else
640 outfile.open(fileName);
641#endif
a79660fb 642 ULong_t miniHeader[3];
643 Int_t miniHeaderSize=sizeof(ULong_t)*3;
644 Int_t version=1; //version of the mini header
2e9f335b 645 //loop over DDLs
646
a79660fb 647 for(Int_t i=0;i<kDDLsNumber;i++){
648 countDDL++;
2e9f335b 649 //write Dummy MINI HEADER
a79660fb 650 miniHeader[0]=size;
651 PackWord(miniHeader[1],magicWord,8,31);
652 PackWord(miniHeader[1],detector,0,7);
653 PackWord(miniHeader[2],i,16,31);
654 PackWord(miniHeader[2],flag,8,15);
655 PackWord(miniHeader[2],version,0,7);
656 miniHeaderPosition=outfile.tellp();
657 outfile.write((char*)(miniHeader),miniHeaderSize);
2e9f335b 658
659 //Loops over Modules of a particular DDL
a79660fb 660 for (Int_t mod=0; mod<kModulesPerDDL; mod++){
661 if(mapSSD[i][mod]!=-1){
2e9f335b 662 ITS->ResetDigits();
a79660fb 663 nbytes += TD->GetEvent(mapSSD[i][mod]);
2e9f335b 664 //For each Module, buf contains the array of data words in Binary format
665 //fIndex gives the number of 32 bits words in the buffer for each module
9f992f70 666 GetDigitsSSD(digitsInITS,mod,mapSSD[i][mod],i,buf);
2e9f335b 667 outfile.write((char *)buf,((fIndex+1)*sizeof(ULong_t)));
668 for(Int_t i=0;i<(fIndex+1);i++){
669 buf[i]=0;
670 }//end for
671 fIndex=-1;
672 }//end if
673 }//end for
674 //Write REAL MINI HEADER
a79660fb 675 ULong_t currentFilePosition=outfile.tellp();
676 outfile.seekp(miniHeaderPosition);
677 size=currentFilePosition-miniHeaderPosition-miniHeaderSize;
2e9f335b 678
a79660fb 679 outfile.write((char*)(&size),sizeof(ULong_t));
680 outfile.seekp(currentFilePosition);
681 if(countDDL==ddlsPerFile){
2e9f335b 682 outfile.close();
a79660fb 683 sliceNumber++;
684 sprintf(fileName,"SSDslice%d",sliceNumber);
685 if(i!=(kDDLsNumber-1))
30c1018e 686#ifndef __DECCXX
2e9f335b 687 outfile.open(fileName,ios::binary);
30c1018e 688#else
689 outfile.open(fileName);
690#endif
a79660fb 691 countDDL=0;
2e9f335b 692 }//end if
693 }//end for
694 outfile.close();
695 return 0;
696}
697
698/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
699
700Int_t AliITSDDLRawData::RawDataSDD(AliITS *ITS,TTree *TD ,Int_t LDCsNumber){
a79660fb 701 //This method creates the Raw data files for SDD detectors
702 //Silicon Drift detector
703 const Int_t kDDLsNumber=12; // Number of DDL in SPD
704 const Int_t kModulesPerDDL=22; // Number of modules in each DDL
2e9f335b 705 //Row ==> DDLs
706 //Column ==> Modules
a79660fb 707 Int_t mapSDD[kDDLsNumber][kModulesPerDDL]= {{240,241,242,246,247,248,252,253,254,258,259,260,264,265,266,270,271,272,276,277,278,-1},
2e9f335b 708 {243,244,245,249,250,251,255,256,257,261,262,263,267,268,269,273,274,275,279,280,281,-1},
709 {282,283,284,288,289,290,294,295,296,300,301,302,306,307,308,312,313,314,318,319,320,-1},
710 {285,286,287,291,292,293,297,298,299,303,304,305,309,310,311,315,316,317,321,322,323,-1},
711 {324,325,326,327,332,333,334,335,340,341,342,343,348,349,350,351,356,357,358,359,364,365},
712 {328,329,330,331,336,337,338,339,344,345,346,347,352,353,354,355,360,361,362,363,368,369},
713 {366,367,372,373,374,375,380,381,382,383,388,389,390,391,396,397,398,399,404,405,406,407},
714 {370,371,376,377,378,379,384,385,386,387,392,393,394,395,400,401,402,403,408,409,410,411},
c391f9d9 715 {412,413,414,415,420,421,422,423,428,429,430,431,436,437,438,439,444,445,446,447,452,453},
2e9f335b 716 {416,417,418,419,424,425,426,427,432,433,434,435,440,441,442,443,448,449,450,451,456,457},
717 {454,455,460,461,462,463,468,469,470,471,476,477,478,479,484,485,486,487,492,493,494,495},
718 {458,459,464,465,466,467,472,473,474,475,480,481,482,483,488,489,490,491,496,497,498,499}};
719
a79660fb 720 Int_t ddlsPerFile=kDDLsNumber/LDCsNumber;
721 if(kDDLsNumber%LDCsNumber)ddlsPerFile++;
9f992f70 722 if(fVerbose)
723 cout<<"Number of DDL per File: "<<ddlsPerFile<<endl;
2e9f335b 724 Int_t subd=1;
a79660fb 725 Int_t countDDL=0;
726 Int_t sliceNumber=1;
727 const Int_t kSize=131072; //256*512
728 ULong_t buf[kSize];
2e9f335b 729 fIndex=-1;
730 Int_t nbytes = 0;
a79660fb 731 TClonesArray *digitsInITS = ITS->DigitsAddress(subd);
2e9f335b 732 char fileName[15];
733
a79660fb 734 ULong_t miniHeaderPosition=0; // variable used to store the position of the Mini Header inside a file
2e9f335b 735 ofstream outfile; // logical name of the output file
a79660fb 736 Int_t flag=0; // 0==> Uncompressed data 1==>Compressed Data
737 Int_t detector=2; // 1==>ITS (Pixel) 2==>ITS (Drift) 3==>ITS (Strip) 0==>TPC ......
738 ULong_t size=0; // size of the data block that follows the mini header
739 Int_t magicWord=0x123456; // Magic word used to distinguish between data and garbage
740 sprintf(fileName,"SDDslice%d",sliceNumber); //The name of the output file. There are as many slides as the number of LDC
30c1018e 741#ifndef __DECCXX
2e9f335b 742 outfile.open(fileName,ios::binary);
30c1018e 743#else
744 outfile.open(fileName);
745#endif
a79660fb 746 ULong_t miniHeader[3];
747 Int_t miniHeaderSize=sizeof(ULong_t)*3;
748 Int_t version=1; //version of the mini header
2e9f335b 749 //loop over DDLs
a79660fb 750 for(Int_t i=0;i<kDDLsNumber;i++){
751 countDDL++;
2e9f335b 752 //write Dummy MINI HEADER
a79660fb 753 miniHeader[0]=size;
754 PackWord(miniHeader[1],magicWord,8,31);
755 PackWord(miniHeader[1],detector,0,7);
756 PackWord(miniHeader[2],i,16,31);
757 PackWord(miniHeader[2],flag,8,15);
758 PackWord(miniHeader[2],version,0,7);
759 miniHeaderPosition=outfile.tellp();
760 outfile.write((char*)(miniHeader),miniHeaderSize);
2e9f335b 761 //Loops over Modules of a particular DDL
a79660fb 762 for (Int_t mod=0; mod<kModulesPerDDL; mod++){
763 if(mapSDD[i][mod]!=-1){
2e9f335b 764 ITS->ResetDigits();
a79660fb 765 nbytes += TD->GetEvent(mapSDD[i][mod]);
2e9f335b 766 //For each Module, buf contains the array of data words in Binary format
767 //fIndex gives the number of 32 bits words in the buffer for each module
a79660fb 768 // cout<<"MODULE NUMBER:"<<mapSDD[i][mod]<<endl;
9f992f70 769 GetDigitsSDD(digitsInITS,mod,mapSDD[i][mod],i,buf);
2e9f335b 770 outfile.write((char *)buf,((fIndex+1)*sizeof(ULong_t)));
771 for(Int_t i=0;i<(fIndex+1);i++){
772 buf[i]=0;
773 }//end for
774 fIndex=-1;
775 }//end if
776 }//end for
777
778 //Write REAL MINI HEADER
a79660fb 779 ULong_t currentFilePosition=outfile.tellp();
780 outfile.seekp(miniHeaderPosition);
781 size=currentFilePosition-miniHeaderPosition-miniHeaderSize;
2e9f335b 782
a79660fb 783 outfile.write((char*)(&size),sizeof(ULong_t));
784 outfile.seekp(currentFilePosition);
785 if(countDDL==ddlsPerFile){
2e9f335b 786 outfile.close();
a79660fb 787 sliceNumber++;
788 sprintf(fileName,"SDDslice%d",sliceNumber);
789 if(i!=(kDDLsNumber-1))
30c1018e 790#ifndef __DECCXX
2e9f335b 791 outfile.open(fileName,ios::binary);
30c1018e 792#else
793 outfile.open(fileName);
794#endif
a79660fb 795 countDDL=0;
2e9f335b 796 }//end if
797 }//end for
798 outfile.close();
799 return 0;
800}
801
802/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
803
804void AliITSDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t EventCnt,ULong_t &BaseWord){
a79660fb 805 //This method writes a chip header
2e9f335b 806 //cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<EventCnt<<endl;
807 BaseWord=0;
808 PackWord(BaseWord,ChipAddr,0,3);
809 PackWord(BaseWord,EventCnt,4,10);
810 PackWord(BaseWord,0x7,11,13);
811 PackWord(BaseWord,0x1,14,15);
812 return;
813}//end WriteChipHeader
814
815/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
816
817void AliITSDDLRawData::ReadChipHeader(Int_t &ChipAddr,Int_t &EventCnt,ULong_t BaseWord){
a79660fb 818 //This method reads a chip header
2e9f335b 819 ULong_t temp=0;
820 UnpackWord(BaseWord,0,3,temp);
821 ChipAddr=(Int_t)temp;
822 UnpackWord(BaseWord,4,10,temp);
823 EventCnt=(Int_t)temp;
9f992f70 824 if(fVerbose)
825 cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<EventCnt<<endl;
2e9f335b 826 return;
827}//end ReadChipHeader
828
829/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
830
831void AliITSDDLRawData::WriteChipTrailer(ULong_t *buf,Int_t ChipHitCount,ULong_t &BaseWord){
a79660fb 832 //This method writes a chip trailer
2e9f335b 833 //pixel fill word
834 if((ChipHitCount%2)!=0){
9f992f70 835 PackWord(BaseWord,0xFEDC,0,15);
2e9f335b 836 }
837 PackWord(BaseWord,ChipHitCount,16,28);
838 PackWord(BaseWord,0x0,30,31);
839 fIndex++;
840 buf[fIndex]=BaseWord;
841 BaseWord=0;
842 return;
843}//end WriteChipTrailer
844
845/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
846
847void AliITSDDLRawData::ReadChipTrailer(Int_t &ChipHitCount,ULong_t BaseWord){
a79660fb 848 //This method reads a chip trailer
2e9f335b 849 ULong_t temp=0;
850 UnpackWord(BaseWord,16,28,temp);
851 ChipHitCount=(Int_t)temp;
852 return;
853}//end ReadChipTrailer
854
855/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
856
857void AliITSDDLRawData::WriteHit(ULong_t *buf,Int_t RowAddr,Int_t HitAddr,ULong_t &BaseWord){
a79660fb 858 //This method writs an hit
2e9f335b 859 if(!BaseWord){
860 PackWord(BaseWord,HitAddr,0,4);
861 PackWord(BaseWord,RowAddr,5,12);
862 PackWord(BaseWord,2,14,15);
863 }//end if
864 else{
865 PackWord(BaseWord,HitAddr,16,20);
866 PackWord(BaseWord,RowAddr,21,28);
867 PackWord(BaseWord,2,30,31);
868 fIndex++;
869 buf[fIndex]=BaseWord;
870 BaseWord=0;
871 }//end else
872 return;
873}//end WriteHit
874
875/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
876
877void AliITSDDLRawData::TestFormat(){
a79660fb 878 //This method generates a text file containing SPD information
879 //Used for debugging
2e9f335b 880 ifstream f;
a79660fb 881 Int_t ldcsNumber=2;
2e9f335b 882 ofstream ftxt("File2.txt");
a79660fb 883 ULong_t size=0;
2e9f335b 884 char filename[15];
a79660fb 885 ULong_t ddlsNumber=0;
886 ULong_t miniHeader[3];
887 Int_t miniHeaderSize=sizeof(ULong_t)*3;
888 for(Int_t i=1;i<=ldcsNumber;i++){
2e9f335b 889 sprintf(filename,"SPDslice%d",i);
30c1018e 890#ifndef __DECCXX
2e9f335b 891 f.open(filename,ios::binary|ios::in);
30c1018e 892#else
893 f.open(filename,ios::in);
894#endif
2e9f335b 895 if(!f){exit(1);}
896 //loop over the DDL block
897 //here the Mini Header is read
a79660fb 898 while( f.read((char*)(miniHeader),miniHeaderSize)){
899 //cout<<"Block Size: "<<size<<endl;
900 size=miniHeader[0];
901 UnpackWord(miniHeader[2],16,31,ddlsNumber);
9f992f70 902 //ftxt<<"DDL NUMBER:"<<ddlsNumber<<endl;
a79660fb 903 ULong_t word=0;
9f992f70 904 ULong_t codeH,codeL=0;
905 ULong_t chip=0;
906 ULong_t half=0;
907 ULong_t col=0;
908 ULong_t row=0;
909 Int_t moduleID=0;
910 ULong_t hitscount=0;
911 Int_t previous=-1;
a79660fb 912 for(ULong_t j=0;j<(size/4);j++){
913 f.read((char*)(&word),sizeof(word)); //32 bits word
9f992f70 914 UnpackWord(word,30,31,codeH);
915 UnpackWord(word,14,15,codeL);
916 if ((codeH==2)&&(codeL==1)){
917 UnpackWord(word,0,3,chip);
918 UnpackWord(word,4,10,half);
919 moduleID=half*2+chip/5;
920 if (moduleID!=previous){
921 if (hitscount){
922 previous=moduleID;
923 hitscount=0;
924 }
925 }
926 chip=chip%5;
927 row=col=0;
928 UnpackWord(word,21,28,row);
929 UnpackWord(word,16,20,col);
930 col=col+32*chip;
931 hitscount++;
932 ftxt<<"DDL:"<<ddlsNumber<<" Mod:"<<moduleID<<" Row:"<<row<<" Col:"<<col<<endl;
933 }//end if
934 else if ((codeH==2)&&(codeL==2)){
935 row=col=0;
936 UnpackWord(word,5,12,row);
937 UnpackWord(word,0,4,col);
938 col=col+32*chip;
939 ftxt<<"DDL:"<<ddlsNumber<<" Mod:"<<moduleID<<" Row:"<<row<<" Col:"<<col<<endl;
940 row=col=0;
941 UnpackWord(word,21,28,row);
942 UnpackWord(word,16,20,col);
943 col=col+32*chip;
944 ftxt<<"DDL:"<<ddlsNumber<<" Mod:"<<moduleID<<" Row:"<<row<<" Col:"<<col<<endl;
945 hitscount++;
946 hitscount++;
947 }//end else if
948 else if ((codeH==0)&&(codeL==2)){
949 row=col=0;
950 UnpackWord(word,5,12,row);
951 UnpackWord(word,0,4,col);
952 col=col+32*chip;
953 hitscount++;
954 ftxt<<"DDL:"<<ddlsNumber<<" Mod:"<<moduleID<<" Row:"<<row<<" Col:"<<col<<endl;
955 }//end else if
2e9f335b 956 }//end for
957 }//end while
cd43b5e1 958 f.clear();
2e9f335b 959 f.close();
960 }//end for
961 ftxt.close();
962 return;
963}