TOF raw data: preliminary implementation and style changes
[u/mrichter/AliRoot.git] / TOF / AliTOFDDLRawData.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 /*
17 Revision 0.01  2004/6/11 A.De Caro, S.B.Sellitto, R.Silvestri
18         First implementation: global methods RawDataTOF
19                                              GetDigits
20                                              (Un)PackWord
21 */
22 //
23 // This class contains the methods to create the Raw Data files
24 // for the TOF detector starting from the Digits.
25 // In this preliminary implementation, we defined the structure
26 // of the ALICE-TOF raw data starting from the current format
27 // for the TOF digits and the TOF raw data.
28 //
29
30 #include <stdlib.h>
31 #include <Riostream.h>
32 #include <TClonesArray.h>
33 #include <TTree.h>
34 #include <TMath.h>
35 #include "AliTOF.h"
36 #include "AliTOFGeometry.h"
37 #include "AliTOFdigit.h"
38 #include "AliTOFDDLRawData.h"
39 #include "AliRawDataHeader.h"
40
41 ClassImp(AliTOFDDLRawData)
42
43 //----------------------------------------------------------------------------------------
44 AliTOFDDLRawData::AliTOFDDLRawData()
45 {
46   //Default constructor
47   fIndex=-1;
48   fVerbose=0;
49 }
50
51 //----------------------------------------------------------------------------------------
52
53 AliTOFDDLRawData::AliTOFDDLRawData(const AliTOFDDLRawData &source) : 
54     TObject(source){
55   //Copy Constructor
56   this->fIndex=source.fIndex;
57   this->fVerbose=source.fVerbose;
58   return;
59 }
60
61 //---------------------------------------------------------------------------------------
62
63 AliTOFDDLRawData& AliTOFDDLRawData::operator=(const AliTOFDDLRawData &source){
64   //Assigment operator
65   this->fIndex=source.fIndex;
66   this->fVerbose=source.fVerbose;
67   return *this;
68 }
69
70 //---------------------------------------------------------------------------------------
71
72 void AliTOFDDLRawData::GetDigits(TClonesArray *TOFdigits,Int_t nDDL,UInt_t *buf)
73 {
74   //This method packs the TOF digits in a proper 32 bits structure
75   Int_t iDDL=(Int_t)((nDDL/4.-(Int_t)(nDDL/4.))*4);
76   Int_t iSector=(Int_t)(nDDL/4.);
77   Int_t iTRM=0;
78   Int_t iTDC=0;
79   Int_t iCH=-1;
80   Int_t sector; 
81   Int_t plate;
82   Int_t strip;
83   Int_t padx;
84   Int_t padz;
85   Int_t totCharge;
86   Int_t timeOfFlight;
87   Int_t error=0;
88   Int_t eureka;
89   UInt_t word;
90   UInt_t baseWord;
91   Int_t ndigits = TOFdigits->GetEntries();
92   AliTOFdigit *digs;
93   ofstream ftxt;
94   if(!ndigits) 
95     {
96       Error("GetDigits", "No found TOF digits\n");      
97       return;
98     }
99
100   if (fVerbose==2) ftxt.open("TOFdigits.txt",ios::app);
101   for (Int_t digit=0;digit<ndigits;digit++) {
102     digs = (AliTOFdigit*)TOFdigits->UncheckedAt(digit);
103     sector=digs->GetSector(); // Sector Number (0-17)
104     plate=digs->GetPlate();   // Plate Number (0-4)
105     strip=digs->GetStrip();   // Strip Number (0-14/18/19)
106     padx=digs->GetPadx();     // Pad Number in x direction (0-47)
107     padz=digs->GetPadz();     // Pad Number in z direction (0-1)
108     eureka=digs->GetTotPad(); // Global Pad Number inside a Sector
109     totCharge = (Int_t)digs->GetAdc();
110     timeOfFlight = (Int_t)digs->GetTdc();
111     /*
112     Int_t istriPlate=0;
113     switch (plate)
114       {
115       case 0:
116         break;
117       case 1:
118         istriPlate = AliTOFGeometry::NStripC();
119         break;
120       case 2:
121         istriPlate = AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB();
122         break;
123       case 3:
124         istriPlate = AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB()+AliTOFGeometry::NStripA();
125         break;
126       case 4:
127         istriPlate = AliTOFGeometry::NStripC()+2*AliTOFGeometry::NStripB()+AliTOFGeometry::NStripA();
128         break;
129       }
130
131     eureka=2*padx+padz+AliTOFGeometry::NpadXStrip()*(strip+istriPlate);
132     
133     if (eureka!=digs->GetTotPad()) printf(" eureka = %d AND digs->GetTotPad() = %d",eureka,digs->GetTotPad());
134     */
135     if (sector!=iSector || (Int_t)((Float_t)eureka/AliTOF::NPadXTRM()/AliTOF::NTRM())!=iDDL) continue;
136     
137     if (fVerbose==2) ftxt <<" Sector: "<<sector<<" plate: "<<plate<<" strip "<<strip<<" padx "<<padx<<" padz "<<padz<<" eureka "<<eureka<<endl;
138     
139     iTRM = (Int_t)((Float_t)eureka/AliTOF::NPadXTRM() - AliTOF::NTRM()*iDDL);
140     
141     iTDC = (Int_t)(AliTOF::NTdc()* 
142                    (
143                     (Float_t)eureka/AliTOF::NPadXTRM() -
144                     (Int_t)((Float_t)eureka/AliTOF::NPadXTRM())
145                     )
146                    );
147     
148     iCH  = (Int_t)(AliTOF::NCh() * 
149                    (
150                     (Float_t)eureka/AliTOF::NPadXTRM()*AliTOF::NTdc() - (Int_t)((Float_t)eureka/AliTOF::NPadXTRM()*AliTOF::NTdc()) -
151                     (Int_t)((Float_t)eureka/AliTOF::NPadXTRM()*AliTOF::NTdc() - (Int_t)((Float_t)eureka/AliTOF::NPadXTRM()*AliTOF::NTdc()))
152                     )
153                    );
154     
155     if (fVerbose==2) ftxt << "DDL: "<<iDDL<<" Sector: "<<sector<<" TRM: "<<iTRM<<" TDC: "<<iTDC<<" Channel: "<<iCH<<" totCharge: "<<totCharge<<" tof: "<<timeOfFlight<<endl;
156     
157     baseWord=0;
158     
159     word=iTRM;
160     PackWord(baseWord,word, 0, 3); // TRM ID
161     word=iTDC;
162     PackWord(baseWord,word, 4, 8); // TDC ID
163     word=iCH;
164     PackWord(baseWord,word, 9,11); // CH ID
165
166     // temporary control
167     if (totCharge<0) word=TMath::Abs(totCharge);
168     else word=totCharge;
169     PackWord(baseWord,word,12,31); // Charge (TOT)
170     
171     fIndex++;
172     buf[fIndex]=baseWord;
173     
174     baseWord=0;
175     
176     word=error;
177     PackWord(baseWord,word,0, 7); // Error flag
178     word=timeOfFlight;
179     PackWord(baseWord,word,8,31); // time-of-flight
180     
181     fIndex++;
182     buf[fIndex]=baseWord;
183     word=0;
184     baseWord=0;
185     
186   }//end for
187   
188   if (fVerbose==2) ftxt.close();
189
190   return;
191
192 }//end GetDigits
193
194 //-------------------------------------------------------------------------------------
195
196 void AliTOFDDLRawData::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit)
197 {
198   //This method packs a word into the Baseword buffer starting form the "StartBit" 
199   //and tacking StopBit-StartBit+1 bits
200   UInt_t dummyWord,offSet;
201   Int_t  length;
202   UInt_t sum;
203   //The BaseWord is being filled with 1 from StartBit to StopBit
204   length=StopBit-StartBit+1;
205   sum=(UInt_t)TMath::Power(2,length)-1;
206
207   if(Word > sum){
208     Error("PackWord", "Word to be filled is not within desired length\n"
209           "Word:%d Start bit:%d Stop Bit:%d",Word,StartBit,StopBit);
210     return;
211   }
212   offSet=sum;
213   offSet<<=StartBit;
214   BaseWord=BaseWord|offSet;
215
216   //The Word to be filled is shifted to the position StartBit
217   //and the remaining  Left and Right bits are filled with 1
218   sum=(UInt_t)TMath::Power(2,StartBit)-1;
219   dummyWord=0xFFFFFFFF<<length;
220   dummyWord +=Word;
221   dummyWord<<=StartBit;
222   dummyWord+=sum;
223   BaseWord=BaseWord&dummyWord;
224
225   return;
226 }
227
228 //------------------------------------------------------------------------------------------------
229
230 void AliTOFDDLRawData::UnpackWord(UInt_t PackedWord, Int_t StartBit, Int_t StopBit, UInt_t &Word)
231 {
232   //This method unpacks a words of StopBit-StartBit+1 bits starting from "StopBits"  
233   UInt_t offSet;
234   Int_t length;
235   length=StopBit-StartBit+1;
236   offSet=(UInt_t)TMath::Power(2,length)-1;
237   offSet<<=StartBit;
238   Word=PackedWord&offSet;
239   Word>>=StartBit;
240   return;
241 }
242
243 //---------------------------------------------------------------------------------------
244
245 Int_t AliTOFDDLRawData::RawDataTOF(TBranch* branch){
246   //This method creates the Raw data files for TOF detector
247   const Int_t kSize=5000; //2*AliTOFGeometry::NpadXSector() 
248                           //max number of digits per DDL file times 2
249   UInt_t buf[kSize];
250   UInt_t baseWord;
251   UInt_t word;
252
253   fIndex=-1;
254
255   TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
256   char fileName[15];
257   ofstream outfile;         // logical name of the output file 
258   AliRawDataHeader header;
259
260   //loop over TOF DDL files
261   for(Int_t i=0;i<72;i++){
262     sprintf(fileName,"TOF_%d.ddl",i); //The name of the output file
263 #ifndef __DECCXX
264     outfile.open(fileName,ios::binary);
265 #else
266     outfile.open(fileName);
267 #endif
268     //write Dummy DATA HEADER
269     UInt_t dataHeaderPosition=outfile.tellp();
270     outfile.write((char*)(&header),sizeof(header));
271
272     baseWord=0;
273     word=i;
274     PackWord(baseWord,word,0, 31); // Number of DDL file
275
276     fIndex++;
277     buf[fIndex]=baseWord;
278
279     branch->GetEvent();
280
281     //For each DDL file, buf contains the array of data words in Binary format
282     //fIndex gives the number of 32 bits words in the buffer for each DDL file
283     GetDigits(digits,i,buf);
284     outfile.write((char *)buf,((fIndex+1)*sizeof(UInt_t)));
285
286     for(Int_t ii=0;ii<(fIndex+1);ii++) buf[ii]=0;
287     fIndex=-1;
288     
289     //Write REAL DATA HEADER
290     UInt_t currentFilePosition=outfile.tellp();
291     outfile.seekp(dataHeaderPosition);
292     header.fSize=currentFilePosition-dataHeaderPosition;
293     header.SetAttribute(0);  // valid data
294     outfile.write((char*)(&header),sizeof(header));
295     outfile.close();
296
297   }//end for
298   
299   return 0;  
300 }
301
302 //-----------------------------------------------------------------------------------------
303 /*
304 void AliTOFDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t EventCnt,UInt_t &BaseWord)
305 {
306   //This method writes a chip header 
307   BaseWord=0;
308   PackWord(BaseWord,ChipAddr,0,3);
309   PackWord(BaseWord,EventCnt,4,10);
310   PackWord(BaseWord,0x7,11,13);
311   PackWord(BaseWord,0x1,14,15);
312   return;
313 }//end WriteChipHeader
314 */
315 //----------------------------------------------------------------------------------------
316 /*
317 void AliTOFDDLRawData::ReadChipHeader(Int_t &ChipAddr,Int_t &EventCnt,UInt_t BaseWord)
318 {
319   //This method reads a chip header
320   UInt_t temp=0;
321   UnpackWord(BaseWord,0,3,temp);
322   ChipAddr=(Int_t)temp;
323   UnpackWord(BaseWord,4,10,temp);
324   EventCnt=(Int_t)temp;
325   if(fVerbose)
326     Info("ReadChipHeader", "Chip:&d Half Stave module:%d",ChipAddr,EventCnt);
327   return;
328 }//end ReadChipHeader
329 */
330 //----------------------------------------------------------------------------------------
331 /*
332 void  AliTOFDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord)
333 {
334   //This method writes a chip trailer
335   //pixel fill word
336   if((ChipHitCount%2)!=0){
337     PackWord(BaseWord,0xFEDC,0,15);
338   }
339   PackWord(BaseWord,ChipHitCount,16,28);
340   PackWord(BaseWord,0x0,30,31);
341   fIndex++;
342   buf[fIndex]=BaseWord;
343   BaseWord=0;
344   return;
345 }//end WriteChipTrailer
346 */
347 //------------------------------------------------------------------------------------------
348 /*
349 void  AliTOFDDLRawData::ReadChipTrailer(Int_t &ChipHitCount,UInt_t BaseWord)
350 {
351   //This method reads a chip trailer
352   UInt_t temp=0;
353   UnpackWord(BaseWord,16,28,temp);
354   ChipHitCount=(Int_t)temp;
355   return;
356 }//end ReadChipTrailer
357 */
358 //------------------------------------------------------------------------------------------