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