SDD raw data treatment: same format for real and simulated data
[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 <TClonesArray.h>
27 #include <TTree.h>
28 #include "AliITSdigit.h"
29 #include "AliITSDDLRawData.h"
30 #include "AliRawDataHeader.h"
31 #include "AliITSRawStreamSPD.h"
32 #include "AliITSRawStreamSDD.h"
33 #include "AliITSRawStreamSSD.h"
34 #include "AliBitPacking.h"
35 #include "AliDAQ.h"
36
37 ClassImp(AliITSDDLRawData)
38
39 ////////////////////////////////////////////////////////////////////////////////////////
40 AliITSDDLRawData::AliITSDDLRawData():
41 fVerbose(0),
42 fIndex(-1),
43 fHalfStaveModule(-1){
44   //Default constructor
45
46 }
47
48 ////////////////////////////////////////////////////////////////////////////////////////
49
50 AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) : 
51     TObject(source),
52 fVerbose(source.fVerbose),
53 fIndex(source.fIndex),
54 fHalfStaveModule(source.fHalfStaveModule){
55   //Copy Constructor
56 }
57
58 ////////////////////////////////////////////////////////////////////////////////////////
59
60 AliITSDDLRawData& AliITSDDLRawData::operator=(const AliITSDDLRawData &source){
61   //Assigment operator
62   this->fIndex=source.fIndex;
63   this->fHalfStaveModule=source.fHalfStaveModule;
64   this->fVerbose=source.fVerbose;
65   return *this;
66 }
67
68 ////////////////////////////////////////////////////////////////////////////////////////
69 //STRIP 
70 //
71
72 void AliITSDDLRawData::GetDigitsSSD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){
73   //This method packs the SSD digits in a proper 32 bits structure
74   Int_t ix;
75   Int_t iz;
76   Int_t is;
77   UInt_t word;
78   UInt_t baseWord;
79   Int_t ndigits = ITSdigits->GetEntries();
80   AliITSdigit *digs;
81   ofstream ftxt;
82   if(ndigits){
83     if (fVerbose==2){
84       ftxt.open("SSDdigits.txt",ios::app);
85     }
86     for (Int_t digit=0;digit<ndigits;digit++) {
87       digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
88       iz=digs->GetCoord1();  // If iz==0, N side and if iz=1 P side
89       ix=digs->GetCoord2();  // Strip Numbar
90       is=digs->GetCompressedSignal();  // ADC Signal
91       // cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
92       if (fVerbose==2)
93         ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl;
94       baseWord=0;
95       word=is-1;
96       AliBitPacking::PackWord(word,baseWord,0,9);//ADC data
97       word=ix;
98       AliBitPacking::PackWord(word,baseWord,10,19);//Strip Number
99       word=iz;      
100       AliBitPacking::PackWord(word,baseWord,20,20);//ADC Channel ID (N or P side)
101       word=mod;
102       AliBitPacking::PackWord(word,baseWord,21,31);//ADC module ID
103       fIndex++;
104       buf[fIndex]=baseWord;
105     }//end for
106   }//end if
107   if (fVerbose==2)
108     ftxt.close();
109   return;
110 }//end GetDigitsSSD
111
112 ////////////////////////////////////////////////////////////////////////////////////////
113 //Silicon Drift Detector
114 //
115
116 void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){  
117   //This method packs the SDD digits in a proper 32 bits structure
118   Int_t ix;
119   Int_t iz;
120   Int_t is;
121   UInt_t word=0;
122   UInt_t baseWord=0;
123   Int_t ndigits = ITSdigits->GetEntries();
124   AliITSdigit *digs;
125   ofstream ftxt;
126   Int_t digarr[512][256];
127   for(Int_t i=0;i<512;i++){
128     for(Int_t j=0;j<256;j++){
129       digarr[i][j]=0;
130     }
131   }
132   //word to select the 12 carlos for the 12 modules
133   UInt_t carlosid=0;
134   if(mod==0) carlosid=805306368;
135   if(mod==1) carlosid=805306369;
136   if(mod==2) carlosid=805306370;
137   if(mod==3) carlosid=805306371;
138   if(mod==4) carlosid=805306372;
139   if(mod==5) carlosid=805306373;
140   if(mod==6) carlosid=805306374;
141   if(mod==7) carlosid=805306375;
142   if(mod==8) carlosid=805306376;
143   if(mod==9) carlosid=805306377;
144   if(mod==10) carlosid=805306378;
145   if(mod==11) carlosid=805306379;
146   
147   fIndex++;
148   buf[fIndex]=carlosid;
149   Int_t first=0;
150   Int_t last=0;
151   Int_t diff=0;
152   Int_t nbit=0;
153   UInt_t word2=0;
154   Bool_t flag = kFALSE;
155   baseWord=0;
156   Int_t bitinfo1[4] = {3,8,3,7}; //vector with info on bit for timebin info 
157   Int_t wordinfo1[4]= {0,0,0,0}; //vector with word info for timebin info 
158   Int_t bitinfo2[2] = {3,18};    //vector with info on bit for EOR (end of row) info
159   Int_t wordinfo2[3]= {1,65593}; //vector with word info for anode info
160
161   /* for time bin info: word          n bits   meaning
162                          0               3      next info is timebin 
163                          8               3      next word is 8 bit long
164                        tb value          8      timebin value
165                        n (2->7)          3      next info is n bit long
166                         signal           n      signal value
167
168      for anode info:     1               3      next 18 bits are for EOR 
169                                                 increments the anode value
170
171                          EOR             18     error codes + other info
172   */
173              
174   if(ndigits){
175     if (fVerbose==2)
176       ftxt.open("SDDdigits.txt",ios::app);
177     for (Int_t digit=0;digit<ndigits;digit++) {
178       digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
179       iz=digs->GetCoord1();  // Anode
180       ix=digs->GetCoord2();  // Time
181       is=digs->GetCompressedSignal();  // ADC Signal
182       digarr[iz][ix]=is;
183         if (fVerbose==2)
184         ftxt<<"DDL:"<<ddl<<" MID:"<<modR<<" An:"<<iz<<" T:"<<ix<<" A:"<<is<<endl;
185       if (is>255){Error("GetDigitsSDD", "bits words is needed)!!!");}
186     }
187       
188     for(Int_t anode=0;anode<512;anode++){
189       if(flag){            
190         last = first+diff-1;
191         AliBitPacking::PackWord(word2,baseWord,first,last);
192         flag = kFALSE;
193         first = last+1;
194         diff=0;
195       }
196       
197       
198       if(anode == 256){
199         last = 0;
200         first = 0;
201         flag = kFALSE;
202         diff = 0;
203         word2=0;
204         
205       }
206       
207       for(Int_t tb=0;tb<256;tb++){
208         if(digarr[anode][tb]!=0){
209           if(flag){      
210             last = first+diff-1;
211             AliBitPacking::PackWord(word2,baseWord,first,last);
212             flag = kFALSE;
213             first = last+1;
214             diff=0;
215           }
216           wordinfo1[1] = tb;
217           //non lossy compression as it is done in Carlos 
218           //(data are already 10to8bit compressed by AMBRA
219
220           /* if value < 8  value = value - (1 << 2) (word is 2 bit long) 
221              if value < 16 value = value - (1 << 3) (word is 3 bit long)
222              if value < 32 value = value - (1 << 4) (word is 4 bit long)
223              if value < 64 value = value - (1 << 5) (word is 5 bit long)
224              if value <128 value = value - (1 << 6) (word is 6 bit long)
225              if value >=128value = value - (1 << 7) (word is 7 bit long)
226
227           */
228           if(digarr[anode][tb]<8){
229             bitinfo1[3] = 2;
230             wordinfo1[2] = 2;
231             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
232           }               
233           if(digarr[anode][tb]>=8 && digarr[anode][tb]<16){
234             bitinfo1[3] = 3;
235             wordinfo1[2] = 3;
236             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
237           }
238           if(digarr[anode][tb]>=16 && digarr[anode][tb]<32){
239             bitinfo1[3] = 4;
240             wordinfo1[2] = 4;
241             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
242           }
243           if(digarr[anode][tb]>=32 && digarr[anode][tb]<64){
244             bitinfo1[3] = 5;
245             wordinfo1[2] = 5;
246             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
247           }
248           if(digarr[anode][tb]>=64 && digarr[anode][tb]<128){
249             bitinfo1[3] = 6;
250             wordinfo1[2] = 6;
251             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
252           }
253           if(digarr[anode][tb]>=128){
254             bitinfo1[3] = 7;
255             wordinfo1[2] = 7;
256             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
257           }
258           
259           for(Int_t ie=0;ie<4;ie++){
260             
261             if(flag){      
262               last = first+diff-1;
263               AliBitPacking::PackWord(word2,baseWord,first,last);
264               flag = kFALSE;
265               first = last+1;
266               diff=0;
267             }
268             last = first+bitinfo1[ie]-1;
269             if(first < 30 && last < 30){                  
270               AliBitPacking::PackWord(wordinfo1[ie],baseWord,first,last); 
271               first = last+1;
272             }
273             else{
274               if(first<=29){
275                 UInt_t w = AliBitPacking::UnpackWord(wordinfo1[ie],0,29-first);
276                 AliBitPacking::PackWord(w,baseWord,first,29);
277                 Int_t lb = 29-first+1;
278                 diff = bitinfo1[ie]-lb;
279                 word2 = AliBitPacking::UnpackWord(wordinfo1[ie],lb,lb+diff-1);
280                 flag = kTRUE;
281                 if(anode<256) word = 2;//channel 0 of carlos
282                 else word = 3; //channel 1 of carlos
283                 AliBitPacking::PackWord(word,baseWord,30,31);
284                 fIndex++;
285                 buf[fIndex]=baseWord;
286                 first=0;
287                 last = 0;
288                 baseWord=0;
289                 word = 0;
290               }
291               else{
292                 word2 = wordinfo1[ie];
293                 diff = bitinfo1[ie];
294                 flag = kTRUE;
295                 if(anode<256) word = 2; //channel 0 of carlos
296                 else word = 3; //channel 1 of carlos
297                 AliBitPacking::PackWord(word,baseWord,30,31);
298                 fIndex++;
299                 buf[fIndex]=baseWord;
300                 first=0;
301                 last=0;
302                 baseWord=0;
303                 word = 0;
304               }
305             }
306           }
307           
308         }//END IF
309         
310       }//end loop on tb
311     
312       for(Int_t i=0;i<2;i++){
313         if(flag){      
314           last = first+diff-1;
315           AliBitPacking::PackWord(word2,baseWord,first,last);
316           flag = kFALSE;
317           first = last+1;
318           diff=0;
319         }
320         
321         word = wordinfo2[i];
322         nbit = bitinfo2[i];
323         last = first+nbit-1;
324         if(first < 30 && last < 30){              
325           AliBitPacking::PackWord(word,baseWord,first,last); //3 bit code =1 -> next 18 bits for EOR
326           first = last+1;
327         }
328         
329         else{
330           if(first<=29){
331             UInt_t w = AliBitPacking::UnpackWord(word,0,29-first);
332             AliBitPacking::PackWord(w,baseWord,first,29);
333             Int_t lb = 29-first+1;
334             diff = nbit-lb;        
335             word2 = AliBitPacking::UnpackWord(word,lb,lb+diff-1);
336             flag = kTRUE;
337             if(anode<256) word = 2;
338             else word = 3;
339             AliBitPacking::PackWord(word,baseWord,30,31);
340             fIndex++;
341             buf[fIndex]=baseWord;
342             first=0;
343             last = 0;
344             baseWord=0;
345             if(anode==255){
346               flag=kFALSE;
347               word2=0;
348             }
349           }
350           else{
351             word2 = word;
352             diff = nbit;
353             flag = kTRUE;
354             if(anode<256) word = 2;
355             else word = 3;
356             AliBitPacking::PackWord(word,baseWord,30,31);
357             fIndex++;
358             buf[fIndex]=baseWord;
359             first=0;
360             last=0;
361             baseWord=0;
362             if(anode==255){
363               flag=kFALSE;
364               word2=0;
365             }
366           }
367         }
368       }
369     } //end for
370     
371   }
372   if(fVerbose==2)
373     ftxt.close();
374   return;
375 }//end GetDigitsSDD
376
377 ////////////////////////////////////////////////////////////////////////////////////////
378 //PIXEL 
379 //
380
381 void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod,Int_t ddl, UInt_t *buf){
382   //This method packs the SPD digits in a proper 32 structure
383   //Since data is zero suppressed,the coordinates for the chip having zero digits 
384   //doesn't get listed in the galice.root file. However the SPD format requires 
385   //the empty chip to be written with chip header and chip trailer.
386   //The index of the half stave is calculated as (mod/2).
387   Int_t ix;
388   Int_t iz;
389   Int_t chipNo=0;
390   UInt_t baseWord=0;
391   UInt_t hitRow=0;
392   Int_t chipHitCount=0;  //Number of Hit in the current chip
393   Int_t previousChip=-1; //Previuos chip respect to the actual aone
394   Int_t ndigits = ITSdigits->GetEntries(); //number of digits in the current module
395   //cout<<"      Number of digits in the current module:"<<ndigits<<" module:"<<mod<<endl;
396   AliITSdigit *digs;
397   fHalfStaveModule++;    //It's a private variable used to distinguish between the firs  
398                          //and the second module of an Half Stave Module
399   ofstream ftxt;
400   if(ndigits){
401     //loop over digits
402     if (fVerbose==2)
403       ftxt.open("SPDdigits.txt",ios::app);
404     for (Int_t digit=0;digit<ndigits;digit++){
405       digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
406       /*---------------------------------------------------------------------------
407        *     Each module contains 5 read out chips of 256 rows and 32 columns.
408        *     So, the cell number in Z direction varies from 0 to 159.  Therefore,
409        *     to get the chip address (0 to 4), we need to divide column number by 32.
410        *     ---------------------------------------------------------------------*/
411       iz=digs->GetCoord1();  // Cell number in Z direction 
412       ix=digs->GetCoord2();  // Cell number in X direction
413       chipNo=iz/32;
414       if(fVerbose==2)
415         ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl;
416       hitRow=iz-chipNo*32;
417       if(fHalfStaveModule){
418         chipNo+=5;
419         fHalfStaveModule=-1;
420       }//end if
421       if(previousChip==-1){
422         //loop over chip without digits 
423         //Even if there aren't digits for a given chip 
424         //the chip header and the chip trailer are stored
425         for(Int_t i=0;i<(iz/32);i++){
426           if(chipNo>4)
427             WriteChipHeader(i+5,(mod/2),baseWord);
428           else
429             WriteChipHeader(i,(mod/2),baseWord);
430           WriteChipTrailer(buf,chipHitCount,baseWord);
431           chipHitCount=0;
432         }//end for
433         WriteChipHeader(chipNo,(mod/2),baseWord);
434         chipHitCount++;
435         WriteHit(buf,ix,hitRow,baseWord);
436         previousChip=chipNo;
437       }//end if
438       else{
439         if(previousChip!=chipNo){
440           WriteChipTrailer(buf,chipHitCount,baseWord);
441           chipHitCount=0;
442           for(Int_t i=previousChip+1;i<chipNo;i++){
443             WriteChipHeader(i,(mod/2),baseWord);
444             WriteChipTrailer(buf,0,baseWord);
445             chipHitCount=0;
446           }//end for
447           WriteChipHeader(chipNo,(mod/2),baseWord);
448           previousChip=chipNo;
449         }//end if
450         chipHitCount++;
451         WriteHit(buf,ix,hitRow,baseWord);
452       }//end else
453     }//end for
454     //Even if there aren't digits for a given chip 
455     //the chip header and the chip trailer are stored
456     Int_t end=4;
457     if(chipNo>4)end+=5;
458     WriteChipTrailer(buf,chipHitCount,baseWord);
459     chipHitCount=0;
460     for(Int_t i=chipNo+1;i<=end;i++){
461       WriteChipHeader(i,(mod/2),baseWord);
462       WriteChipTrailer(buf,0,baseWord);
463       chipHitCount=0;
464     }//end for
465   }//end if
466   else{
467     //In this module there aren't digits but
468     //the chip header and chip trailer are store anyway
469     if(fHalfStaveModule){
470       chipNo=5;
471       fHalfStaveModule=-1;
472     }//end if
473     for(Int_t i=0;i<5;i++){
474       WriteChipHeader(chipNo+i,(mod/2),baseWord);
475       WriteChipTrailer(buf,chipHitCount,baseWord);
476       chipHitCount=0;
477     }//end for
478   }//end else 
479   if(fVerbose==2)
480     ftxt.close();
481   return;
482 }//end GetDigitsSPD
483
484 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
485
486 Int_t AliITSDDLRawData::RawDataSPD(TBranch* branch){
487   //This method creates the Raw data files for SPD detectors
488   const Int_t kSize=21000; //256*32*5=40960 max number of digits per module
489   UInt_t buf[kSize];      //One buffer cell can contain 2 digits 
490   fIndex=-1;
491
492   TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
493   char fileName[15];
494   ofstream outfile;         // logical name of the output file 
495   AliRawDataHeader header;
496
497   //loop over DDLs
498   for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSPD");i++){
499     strcpy(fileName,AliDAQ::DdlFileName("ITSSPD",i)); //The name of the output file.
500 #ifndef __DECCXX
501     outfile.open(fileName,ios::binary);
502 #else
503     outfile.open(fileName);
504 #endif
505     //write Dummy DATA HEADER
506     UInt_t dataHeaderPosition=outfile.tellp();
507     outfile.write((char*)(&header),sizeof(header));
508     //Loops over Modules of a particular DDL
509     for (Int_t mod=0; mod<AliITSRawStreamSPD::kModulesPerDDL; mod++){
510       Int_t moduleNumber = AliITSRawStreamSPD::GetModuleNumber(i, mod);
511       digits->Clear();
512       branch->GetEvent(moduleNumber);
513       //For each Module, buf contains the array of data words in Binary format    
514       //fIndex gives the number of 32 bits words in the buffer for each module
515       GetDigitsSPD(digits,mod,i,buf);
516       outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
517       for(Int_t i=0;i<(fIndex+1);i++){
518         buf[i]=0;
519       }//end for
520       fIndex=-1;
521     }//end for
522     
523     //Write REAL DATA HEADER
524     UInt_t currentFilePosition=outfile.tellp();
525     outfile.seekp(dataHeaderPosition);
526     header.fSize=currentFilePosition-dataHeaderPosition;
527     outfile.write((char*)(&header),sizeof(header));
528     outfile.close();
529   }//end for
530
531   return 0;  
532 }
533
534 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
535
536 Int_t AliITSDDLRawData::RawDataSSD(TBranch* branch){
537
538   //This method creates the Raw data files for SSD detectors
539   const Int_t kSize=1536;//768*2 Number of stripe * number of sides(N and P)
540   UInt_t buf[kSize];      
541   fIndex=-1;
542
543   TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
544   char fileName[15];
545   ofstream outfile;         // logical name of the output file 
546   AliRawDataHeader header;
547
548   //loop over DDLs  
549   for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSSD");i++){
550     strcpy(fileName,AliDAQ::DdlFileName("ITSSSD",i)); //The name of the output file.
551 #ifndef __DECCXX
552     outfile.open(fileName,ios::binary);
553 #else
554     outfile.open(fileName);
555 #endif
556     //write Dummy DATA HEADER
557     UInt_t dataHeaderPosition=outfile.tellp();
558     outfile.write((char*)(&header),sizeof(header));
559     
560     //Loops over Modules of a particular DDL
561     for (Int_t mod=0; mod<AliITSRawStreamSSD::kModulesPerDDL; mod++){
562       Int_t moduleNumber = AliITSRawStreamSSD::GetModuleNumber(i, mod);
563       if(moduleNumber!=-1){
564         digits->Clear();
565         branch->GetEvent(moduleNumber);
566         //For each Module, buf contains the array of data words in Binary format          
567         //fIndex gives the number of 32 bits words in the buffer for each module
568         GetDigitsSSD(digits,mod,moduleNumber,i,buf);
569         outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
570         fIndex=-1;
571       }//end if
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     header.SetAttribute(0);  // valid data
579     outfile.write((char*)(&header),sizeof(header));
580     outfile.close();
581   }//end for
582
583   return 0;  
584 }
585
586 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
587
588 Int_t AliITSDDLRawData::RawDataSDD(TBranch* branch){
589     //This method creates the Raw data files for SDD detectors
590   const Int_t kSize=131072; //256*512
591   UInt_t buf[kSize];      
592   fIndex=-1;
593
594   TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
595   char fileName[15];
596   ofstream outfile;             // logical name of the output file 
597   AliRawDataHeader header;
598   UInt_t skippedword = AliBitPacking::PackWord(2,skippedword,0,31);
599
600   //loop over DDLs  
601   for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSDD");i++){
602     strcpy(fileName,AliDAQ::DdlFileName("ITSSDD",i)); //The name of the output file.
603 #ifndef __DECCXX
604     outfile.open(fileName,ios::binary);
605 #else
606     outfile.open(fileName);
607 #endif
608     //write Dummy DATA HEADER
609     UInt_t dataHeaderPosition=outfile.tellp();
610     outfile.write((char*)(&header),sizeof(header));
611
612     //first 8 "dummy" words to be skipped
613     for(Int_t iw=0;iw<8;iw++){
614         outfile.write((char*)&skippedword,sizeof(skippedword));
615     }
616    
617     //Loops over Modules of a particular DDL
618     for (Int_t mod=0; mod<AliITSRawStreamSDD::kModulesPerDDL; mod++){
619       Int_t moduleNumber = AliITSRawStreamSDD::GetModuleNumber(i, mod);
620       if(moduleNumber!=-1){
621         digits->Clear();
622         branch->GetEvent(moduleNumber);
623
624         //For each Module, buf contains the array of data words in Binary format          
625         //fIndex gives the number of 32 bits words in the buffer for each module
626         //      cout<<"MODULE NUMBER:"<<mapSDD[i][mod]<<endl;
627         GetDigitsSDD(digits,mod,moduleNumber,i,buf);
628         outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
629         fIndex=-1;
630       }//end if
631     }//end for
632     
633     //Write REAL DATA HEADER
634     UInt_t currentFilePosition=outfile.tellp();
635     outfile.seekp(dataHeaderPosition);
636     header.fSize=currentFilePosition-dataHeaderPosition;
637     header.SetAttribute(0);  // valid data
638     outfile.write((char*)(&header),sizeof(header));
639
640     outfile.close();
641   }//end for
642
643   return 0;  
644 }
645
646 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
647
648 void AliITSDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t halfStave,UInt_t &BaseWord){
649   //This method writes a chip header 
650   //cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<halfStave<<endl;
651   BaseWord=0;
652   AliBitPacking::PackWord(ChipAddr,BaseWord,16,19);
653   //  At the moment the event count is always 0 (bits 20-26)
654   AliBitPacking::PackWord(0,BaseWord,20,26);
655   AliBitPacking::PackWord(halfStave,BaseWord,27,29);
656   AliBitPacking::PackWord(0x1,BaseWord,30,31);
657   return;
658 }//end WriteChipHeader
659
660 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
661
662 void  AliITSDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord){
663   //This method writes a chip trailer
664   //pixel fill word
665   if((ChipHitCount%2)!=0){
666     AliBitPacking::PackWord(0xC000,BaseWord,16,31);
667   }
668   AliBitPacking::PackWord(ChipHitCount,BaseWord,0,13);
669   AliBitPacking::PackWord(0x0,BaseWord,14,15);
670   fIndex++;
671   buf[fIndex]=BaseWord;
672   BaseWord=0;
673   return;
674 }//end WriteChipTrailer
675
676 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
677
678 void  AliITSDDLRawData::WriteHit(UInt_t *buf,Int_t RowAddr,Int_t HitAddr,UInt_t &BaseWord){
679   //This method writs an hit
680   if(!BaseWord){
681     AliBitPacking::PackWord(HitAddr,BaseWord,16,20);
682     AliBitPacking::PackWord(RowAddr,BaseWord,21,28);
683     AliBitPacking::PackWord(2,BaseWord,30,31);
684   }//end if
685   else{
686     AliBitPacking::PackWord(HitAddr,BaseWord,0,4);
687     AliBitPacking::PackWord(RowAddr,BaseWord,5,12);
688     AliBitPacking::PackWord(2,BaseWord,14,15);
689     fIndex++;
690     buf[fIndex]=BaseWord;
691     BaseWord=0;
692   }//end else
693   return;
694 }//end WriteHit
695