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