New TOF version with holes for PHOS/RICH
[u/mrichter/AliRoot.git] / TOF / AliTOFD.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 $Log$
18 */
19
20 #include "AliTOF.h"
21 #include "AliTOFD.h"
22 #include "TObject.h"
23
24 //******************************************************************************
25
26 ClassImp(AliTOFRawDigit)
27
28 //______________________________________________________________________________
29 AliTOFRawDigit::AliTOFRawDigit()
30 //
31 // Constructor of AliTOFRawDigit class
32 //
33 {
34   fTreeD     = 0;
35   fRawDigits = 0;
36 }
37
38 //******************************************************************************
39
40 ClassImp(AliTOFRoc)
41
42 //______________________________________________________________________________
43 AliTOFRoc::AliTOFRoc()
44 //
45 // Constructor of AliTOFRoc class
46 // The class represents a ROC in the TARODA system
47 //
48 {
49   Items = 0;
50   Size  = 0;
51 }
52
53 //______________________________________________________________________________
54 AliTOFRoc::~AliTOFRoc(){}
55
56 //______________________________________________________________________________
57 Int_t AliTOFRoc::AddItem(Int_t Fec, Int_t Tdc, Int_t Error,
58                          Float_t Charge, Float_t Time)
59 //
60 // Adds an item (i.e. the charge, the TOF and the 
61 // cohordinates of a hit pad) to the ROC class.
62 //
63 {
64    Items++;
65    SetCharge(Items,Fec,Tdc,Charge);
66    SetTime  (Items,Error,Time);
67    return Items;   
68 }
69
70 //______________________________________________________________________________
71 void AliTOFRoc::SetHeader()
72 //
73 // Calculate the header line of the ROC in the raw data file
74 //
75 {
76    Header  = NRoc<<28;
77    Header += Size;
78 }
79
80
81 //______________________________________________________________________________
82 void AliTOFRoc::SetTime(UInt_t Item, UInt_t Error, Float_t RealTime)
83 //
84 // Calculate the raw data line relative to the TDC
85 // output of a pad in the current ROC.
86 //
87 {
88    UInt_t Itime;
89    Itime = (UInt_t)(RealTime/50.);
90    if (Itime >= pow(2,24)) Itime = 2^24-1;
91    Error <<= 24;
92    TimeRow[Item]= Error+Itime;
93 }
94
95 //______________________________________________________________________________
96 void AliTOFRoc::SetCharge(UInt_t Item, UInt_t Fec, UInt_t Tdc, Float_t RealCharge)
97 //
98 // Calculate the raw data line relative to the ADC 
99 // output of a pad in the current ROC.
100 //
101 {
102    UInt_t ICharge;
103    if (NRoc>=pow(2,4)) NRoc = 0;
104    NRoc <<= 28;
105    if (Fec >=pow(2,6))  Fec = 0;
106    Fec  <<= 22;
107    if (Tdc >=pow(2,6))  Tdc = 0;
108    Tdc  <<= 16;
109    ICharge = (UInt_t)(RealCharge/50.);
110    if(ICharge>=pow(2,16)) ICharge = (UInt_t)pow(2,16)-1;
111    ChrgRow[Item] = ICharge+NRoc+Fec+Tdc;
112 }
113
114 //______________________________________________________________________________
115 void AliTOFRoc::SetTime(UInt_t Item, UInt_t tir)
116 //
117 // Writes the raw data line relative to the TDC
118 //
119 {
120    ChrgRow[Item]=tir;
121 }
122
123 //______________________________________________________________________________
124 void AliTOFRoc::SetCharge(UInt_t Item, UInt_t chr)
125 //
126 // Writes the raw data line relative to the ADC
127 //
128 {
129    ChrgRow[Item]=chr;
130 }
131
132 //______________________________________________________________________________
133 Float_t AliTOFRoc::GetCharge(Int_t Item)
134 //
135 // Reads the effective value of the charge starting
136 // from the line of the raw data
137 //
138 {
139    UInt_t  Charge  = ChrgRow[Item]&0x0000ffff;
140    Float_t ACharge = (Float_t)Charge*50.;
141    return ACharge;
142 }
143
144 //______________________________________________________________________________
145 Float_t AliTOFRoc::GetTime(Int_t Item, UInt_t& Error)
146 //
147 // Reads the effective value of the time of flight starting
148 // from the line of the raw data
149 //
150 {
151    UInt_t  Time  = TimeRow[Item]&0x00ffffff;
152    Float_t ATime = (Float_t)Time*50.;
153    Error = TimeRow[Item]>>24;
154    return ATime; 
155 }
156
157 //______________________________________________________________________________
158 Int_t AliTOFRoc::GetTotPad(Int_t Item)
159 //
160 // Reads the cohordinates of the pad starting
161 // from the line of the raw data
162 //
163 {
164    UInt_t NRoc = (ChrgRow[Item]&0xf0000000)>>28;
165    UInt_t NFec = (ChrgRow[Item]&0x0fc00000)>>22;
166    UInt_t NTdc = (ChrgRow[Item]&0x003f0000)>>16;
167    UInt_t Pad = NRoc*32*32+NFec*32+NTdc;
168    return Pad; 
169 }
170
171 //______________________________________________________________________________
172 UInt_t AliTOFRoc::GetCheckSum()
173 //
174 // Calculate the checksum word of the current ROC
175 // 
176 {
177    UInt_t CheckSum=0;
178    for(Int_t i=0; i<Items; i++){
179       CheckSum += BitCount(GetChrgRow(i));
180       CheckSum += BitCount(GetTimeRow(i));
181    }
182    return CheckSum;
183 }
184
185 //______________________________________________________________________________
186 UInt_t AliTOFRoc::BitCount(UInt_t x)
187 //
188 // Count the "1" bit in the current word
189 //
190 {
191    UInt_t count=0;
192    for (count=0; x!=0; x>>=1){
193       if(x&0x00000001) count++;
194    }
195    return count;
196 }
197
198 //______________________________________________________________________________
199 UInt_t AliTOFRoc::SetSize()
200 //
201 // Reads the size of data from current ROC starting
202 // from the header line of the raw data
203 //
204 {
205    Size = Header&0x0000ffff;
206    Items = (Size-4)/4;
207    return Size;
208 }
209
210
211 //******************************************************************************
212
213 ClassImp(AliTOFRawSector)
214
215 //______________________________________________________________________________
216 AliTOFRawSector::AliTOFRawSector()
217 //
218 // Constructor of AliTOFRawSector class
219 // Each sector is in effect a 
220 // TClonesArray of 14 AliTOFRoc Objects
221 //
222 {
223    fRocData = new TClonesArray("AliTOFRoc",14);   
224 }
225
226 //______________________________________________________________________________
227 AliTOFRawSector::~AliTOFRawSector()
228 {
229    delete fRocData;
230 }
231
232 //______________________________________________________________________________
233 void AliTOFRawSector::WriteSector()
234 //
235 // Starting from the raw data objects writes a binary file
236 // similar to real raw data.
237 //
238 {
239     FILE *rawfile;
240     rawfile = fopen("rawdata.dat","w");
241     
242 //    fprintf(rawfile,Header);
243     
244     Int_t nRoc;
245     
246     for(nRoc=1; nRoc<=14; nRoc++){
247        AliTOFRoc* currentRoc = (AliTOFRoc*)fRocData->UncheckedAt(nRoc);
248        currentRoc->SetHeader;
249        UInt_t RocHeader = currentRoc->Header;
250 //      fprintf(rawfile,RocHeader);
251     }
252     
253     for(nRoc=1; nRoc<=14; nRoc++){
254        AliTOFRoc* currentRoc = (AliTOFRoc*)fRocData->UncheckedAt(nRoc);
255        Int_t rocItems = currentRoc->Items;
256
257        for(Int_t nItem=1; nItem<=rocItems;nItem++){
258           UInt_t TimeRow = currentRoc->GetTimeRow(nItem);
259 //          fprintf(rawfile,TimeRow);
260           UInt_t ChrgRow = currentRoc->GetTimeRow(nItem);
261 //          fprintf(rawfile,ChrgRow);
262        }
263     }
264     
265     UInt_t EndOfSector = GlobalCheckSum;
266 //    fprintf(rawfile,EndOfSector);
267 }
268
269 //______________________________________________________________________________
270 void AliTOFRawSector::ReadSector()
271 //
272 // Starting from raw data initialize and write the 
273 // Raw Data objects 
274 //(i.e. a TClonesArray of 18 AliTOFRawSector)
275 //
276 {
277     FILE *rawfile;
278     rawfile = fopen("rawdata.dat","r");
279     
280 //    fscanf(rawfile,Header);
281     Int_t nRoc;
282     
283     for(nRoc=1; nRoc<=14; nRoc++){
284        AliTOFRoc* currentRoc = (AliTOFRoc*)fRocData->UncheckedAt(nRoc);
285        UInt_t RocHeader;
286  //      fscanf(rawfile,RocHeader);
287        currentRoc->SetHeader(RocHeader);
288     }
289     
290     UInt_t SCMWord;
291 //    fscanf(rawfile,SCMWord);
292     
293     for(nRoc=1; nRoc<=14; nRoc++){
294        AliTOFRoc* currentRoc = (AliTOFRoc*)fRocData->UncheckedAt(nRoc);
295        Int_t Size = currentRoc->SetSize();
296        Int_t nItems = currentRoc->Items;
297        for(Int_t nrow=0; nrow<=nItems; nrow++){
298           UInt_t charRow,timeRow;
299 //        fscanf(rawfile, charRow);
300           currentRoc->SetTime(nrow, charRow);
301 //         fscanf(rawfile, timeRow);
302           currentRoc->SetTime(nrow, timeRow);
303        }
304        Int_t FinalWord;
305 //       fscanf(rawfile,FinalWord);              
306     }
307 //    fscanf(rawfile,GlobalCheckSum);
308 }
309