Tunning of raw data buffer and macro reading raw data
[u/mrichter/AliRoot.git] / AD / AliADBuffer.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 /* $Id$ */
16
17 // Storing digits in a binary file
18 // according to the DDL mapping
19 // Author: B. Cheynis
20
21 #include <Riostream.h>
22 #include <TObjArray.h>
23 #include <TMath.h>
24
25 #include "AliLog.h"
26 #include "AliRawDataHeaderSim.h"
27 #include "AliADBuffer.h"
28 #include "AliADdigit.h"
29 #include "AliADConst.h"
30
31 ClassImp(AliADBuffer)
32
33 //_____________________________________________________________________________
34 AliADBuffer::AliADBuffer():TObject(),
35     fRemainingWord(0),
36     f()
37 {
38   //
39   // default constructor
40   //
41 }
42 //_____________________________________________________________________________
43 AliADBuffer::AliADBuffer(const char* fileName):TObject(),
44     fRemainingWord(0),
45     f()
46 {
47   // Constructor
48   f = new AliFstream(fileName);
49   AliRawDataHeaderSim header;
50   f->WriteBuffer((char*)(&header), sizeof(header));
51
52 }
53
54 //_____________________________________________________________________________
55 AliADBuffer::~AliADBuffer(){
56   // Destructor, it closes the IO stream
57   AliRawDataHeaderSim header;
58   header.fSize = f->Tellp();
59   header.SetAttribute(0);  // valid data
60   f->Seekp(0);
61   f->WriteBuffer((char*)(&header), sizeof(header));
62   delete f;
63 }
64
65 //_____________________________________________________________________________
66 void AliADBuffer::WriteTriggerInfo(UInt_t trigger) {
67   // The method writes AD trigger information
68   // This info is contained in the first two
69   // raw-data words following the raw-data header (CDH).
70
71   f->WriteBuffer((char*)(&trigger),sizeof(trigger));
72
73   // By default all the inputs are unmasked... Hopefully
74   UInt_t triggerMask = 0xffff;
75   f->WriteBuffer((char*)(&triggerMask),sizeof(triggerMask));
76 }
77
78 //_____________________________________________________________________________
79 void AliADBuffer::WriteTriggerScalers() {
80   // The method writes the AD trigger scalers
81   // For the moment there is no way to simulate
82   // this, so we fill the necessary 16 words with 0
83
84   // First the general trigger scalers (16 of them)
85   for(Int_t i = 0; i < 16; i++) {
86       UInt_t data = 0;
87       f->WriteBuffer((char*)&data,sizeof(data));
88   }
89 }
90
91 //_____________________________________________________________________________
92 void AliADBuffer::WriteBunchNumbers() {
93   // The method writes the Bunch Numbers corresponding 
94   // to the 10 Minimum Bias events
95   // For the moment there is no way to simulate
96   // this, so we fill the necessary 10 words with 0
97
98   // First the bunch crossing numbers
99   // for these 10 events
100   
101   for(Int_t i = 0; i < 10; i++) {
102       UInt_t data = 0;
103       f->WriteBuffer((char*)&data,sizeof(data));
104   }
105
106 }
107
108 //_____________________________________________________________________________
109 void AliADBuffer::WriteChannel(Int_t channel, Short_t *adc, Bool_t integrator){
110   // It writes AD charge information into a raw data file. 
111   // Being called by Digits2Raw
112   
113   UInt_t data = 0;
114   for(Int_t i = 0; i < kNClocks; ++i) {
115     if (adc[i] > 1023) {
116       AliWarning(Form("ADC (channel=%d) saturated: %d. Truncating to 1023",channel,adc[i]));
117       adc[i] = 1023;
118     }
119   }
120   
121   if(channel%2 == 0) {
122     for(Int_t i = 0; i < (kNClocks/2); ++i) {
123       data =   (adc[2*i] & 0x3ff);
124       data |= ((integrator & 0x1) << 10);
125
126       data |= ((adc[2*i+1] & 0x3ff) << 16);
127       data |= ((!integrator & 0x1) << 26);
128
129       f->WriteBuffer((char*)&data,sizeof(data));
130     }
131     fRemainingWord = (adc[kNClocks-1] & 0x3ff);
132     fRemainingWord |= ((integrator & 0x1) << 10);
133   }
134   else {
135     data = fRemainingWord;
136     data |= ((adc[0] & 0x3ff) << 16);
137     data |= ((integrator & 0x1) << 26);
138     f->WriteBuffer((char*)&data,sizeof(data));
139
140     for(Int_t i = 1; i <= (kNClocks/2); ++i) {
141       data =   (adc[2*i-1] & 0x3ff);
142       data |= ((!integrator & 0x1) << 10);
143
144       data |= ((adc[2*i] & 0x3ff) << 16);
145       data |= ((integrator & 0x1) << 26);
146
147       f->WriteBuffer((char*)&data,sizeof(data));
148     }
149   }
150     
151 }
152
153 //_____________________________________________________________________________
154 void AliADBuffer::WriteBeamFlags() {
155
156 //void AliADBuffer::WriteBeamFlags(Bool_t *bbFlag, Bool_t *bgFlag) {
157   // The method writes information about
158   // the Beam-Beam and Beam-Gas flags i.e. 
159   // 10  shorts for the 4 channels 
160   // of half a CIU card
161
162   // Beam-beam and beam-gas flags are available
163   // only for the triggered event-of-interest (sample index = 10)
164   // As soon as trigger simulation would become more complex
165   // and would allow to simulate neighbouring samples, this code
166   // should be extended in order to fill all (or fraction) of the
167   // flags
168   /*/
169   UShort_t data = 0;
170   
171   for(Int_t iEvOfInt = 0; iEvOfInt < kNClocks; iEvOfInt=iEvOfInt+2) {
172         for(Int_t iChannel = 0; iChannel < 4; iChannel++) {
173           data = 0;
174           if (bbFlag[iChannel]) data |= ((bbFlag[iChannel] & 0x1) << 2*iChannel);
175           if (bgFlag[iChannel]) data |= ((bgFlag[iChannel] & 0x1) << 2*iChannel+1);
176           
177           if(iEvOfInt < (kNClocks - 1)) {      
178              if (bbFlag[iChannel]) data |= ((bbFlag[iChannel] & 0x1) << 8 + 2*iChannel);
179              if (bgFlag[iChannel]) data |= ((bgFlag[iChannel] & 0x1) << 8 + 2*iChannel+1);
180           }
181           f->WriteBuffer((char*)&data,sizeof(data));
182         }
183       }
184    data = 0;
185    f->WriteBuffer((char*)&data,sizeof(data));//Empty short in the end
186    /*/
187   for(Int_t i = 0; i < 6; i++) {
188         UInt_t data = 0;
189         f->WriteBuffer((char*)&data,sizeof(data));
190         }
191 }
192
193 //_____________________________________________________________________________
194 void AliADBuffer::WriteMBInfo() {
195   // The method writes information about
196   // the 10 previous minimum-bias events
197   // i.e. channels charge for each of these
198   // 10 events (4*10 shorts for the 4 channels 
199   // of half a CIU card)
200     
201   for(Int_t i = 0; i < 20; i++) {
202     UInt_t data = 0;
203     f->WriteBuffer((char*)&data,sizeof(data));
204   }
205 }
206
207
208 //_____________________________________________________________________________
209 void AliADBuffer::WriteMBFlags() {
210   // The method writes information about
211   // the Minimum Bias flags
212   // 5 16-bits words for the 4 channels 
213   // of half a CIU card + one empty 16-bit
214
215
216   for(Int_t i = 0; i < 3; i++) {
217     UInt_t data = 0;
218     f->WriteBuffer((char*)&data,sizeof(data));  
219     }
220 }
221
222 //_____________________________________________________________________________
223 void AliADBuffer::WriteBeamScalers() {
224   // The method writes the AD beam scalers
225   // For the moment there is no way to simulate
226   // this, so we fill the necessary words with 0
227
228   // Beam-beam and beam-gas scalers for
229   // 4 individual channel (4x4 words)
230   // (64-bit + 64-bit)*4 = 32bit * 16
231   
232   for(Int_t i = 0; i < 16; i++) {
233     UInt_t data = 0;
234     f->WriteBuffer((char*)&data,sizeof(data));
235   }
236 }
237
238
239
240 //_____________________________________________________________________________
241 void AliADBuffer::WriteTiming(Float_t time, Float_t width) {
242   // It writes the timing information into a raw data file. 
243   // Being called by Digits2Raw
244
245   // Writes the timing information
246   UInt_t data = TMath::Nint(time) & 0xfff;
247   data |= (TMath::Nint(width) & 0x7f) << 12;
248   f->WriteBuffer((char*)&data,sizeof(data));
249 }