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