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