4347b38f |
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 | /* $Id$ */ |
17 | |
18 | ////////////////////////////////////////////////////////////////////// |
19 | // |
20 | // Buffer to read RAW ALTRO FMD format from a AliRawReader |
21 | // |
22 | // Currently, I had to overload the Next member function and introduce |
23 | // my own members fMyData, fMyPosition, fMyCount, and fMyBunchLength. |
24 | // The reason is, that we can use the fMyCount to determine the |
25 | // sampling rate used in the ALTRO. However, |
26 | // AliAltroBuffer::fCount is private, so we can not access it. |
27 | // |
28 | // If it wasn't I'd implement Next as |
29 | // |
30 | // Bool_t |
31 | // AliFMDRawStreamer::Next() |
32 | // { |
33 | // if (AliAltroRawStreamer::Next()) { |
34 | // if (fPrevPad != fPad) |
35 | // fSampleRate = (fCount - 2) / 128; |
36 | // return kTRUE; |
37 | // } |
38 | // return kFALSE; |
39 | // } |
40 | // |
41 | ////////////////////////////////////////////////////////////////////// |
42 | #ifndef ALIFMDRAWSTREAM_H |
43 | # include "AliFMDRawStream.h" |
44 | #endif |
45 | #ifndef ALIRAWREADER_H |
46 | # include "AliRawReader.h" |
47 | #endif |
48 | #ifndef __IOSTREAM__ |
49 | # include <iostream> |
50 | #endif |
51 | |
52 | //____________________________________________________________________ |
53 | ClassImp(AliFMDRawStream); |
54 | |
55 | //____________________________________________________________________ |
56 | AliFMDRawStream::AliFMDRawStream(AliRawReader* reader) |
57 | : AliAltroRawStream(reader), |
58 | // fMyData(0), |
59 | // fMyPosition(0), |
60 | // fMyCount(0), |
61 | // fMyBunchLength(0), |
62 | fPrevTime(-1) |
63 | {} |
64 | |
65 | |
66 | |
67 | //_____________________________________________________________________________ |
68 | Bool_t |
69 | AliFMDRawStream::Next() |
70 | { |
71 | // read the next raw digit |
72 | // returns kFALSE if there is no digit left |
73 | fPrevTime = fTime; |
74 | if (AliAltroRawStream::Next()) { |
75 | if (fPrevPad != fPad) { |
76 | fSampleRate = fTimeBunch / 128; |
48f3f263 |
77 | #if 0 |
4347b38f |
78 | std::cout << "Setting Sample rate to (" << fTimeBunch << "/" |
79 | << 128 << "=" << fSampleRate << std::endl; |
80 | #endif |
81 | } |
82 | return kTRUE; |
83 | } |
84 | return kFALSE; |
85 | } |
86 | |
87 | #if 0 |
88 | //_____________________________________________________________________________ |
89 | Bool_t |
90 | AliFMDRawStream::Next() |
91 | { |
92 | // read the next raw digit |
93 | // returns kFALSE if there is no digit left |
94 | fPrevSector = fSector; |
95 | fPrevRow = fRow; |
96 | fPrevPad = fPad; |
97 | fPrevTime = fTime; |
98 | |
99 | while (fMyCount == 0) { // next trailer |
100 | if (fMyPosition <= 0) { // next payload |
101 | do { |
102 | if (!fRawReader->ReadNextData(fMyData)) return kFALSE; |
103 | } while (fRawReader->GetDataSize() == 0); |
104 | |
105 | fMyPosition = (fRawReader->GetDataSize() * 8) / 10; |
106 | while (Get10BitWord(fMyData, fMyPosition-1) == 0x2AA) fMyPosition--; |
107 | } |
108 | |
109 | if (fMyPosition > 0) { |
110 | // read the trailer |
111 | if (fMyPosition <= 4) { |
112 | Error("Next", "could not read trailer"); |
113 | return kFALSE; |
114 | } |
115 | fSector = Get10BitWord(fMyData, --fMyPosition); |
116 | fRow = Get10BitWord(fMyData, --fMyPosition); |
117 | fPad = Get10BitWord(fMyData, --fMyPosition); |
118 | fMyCount = Get10BitWord(fMyData, --fMyPosition); |
119 | |
120 | fMyPosition -= (4 - (fMyCount % 4)) % 4; // skip fill words |
121 | fMyBunchLength = 0; |
122 | |
123 | // Set the sample rate, based on the number of samples in the |
124 | // channel. |
125 | fSampleRate = (fMyCount - 2) / 128; |
126 | #if 0 |
127 | std::cout << "Setting Sample rate to (" << fMyCount << " - 2)/" |
128 | << 128 << "=" << fSampleRate << std::endl; |
129 | #endif |
130 | } |
131 | } |
132 | |
133 | if (fMyBunchLength == 0) { |
134 | if (fMyPosition <= 0) { |
135 | Error("Next", "could not read bunch length"); |
136 | return kFALSE; |
137 | } |
138 | fMyBunchLength = Get10BitWord(fMyData, --fMyPosition) - 2; |
139 | fMyCount--; |
140 | |
141 | |
142 | if (fMyPosition <= 0) { |
143 | Error("Next", "could not read time bin"); |
144 | return kFALSE; |
145 | } |
146 | fTime = Get10BitWord(fMyData, --fMyPosition); |
147 | fMyCount--; |
148 | } else { |
149 | fTime--; |
150 | } |
151 | |
152 | if (fMyPosition <= 0) { |
153 | Error("Next", "could not read sample amplitude"); |
154 | return kFALSE; |
155 | } |
156 | fSignal = Get10BitWord(fMyData, --fMyPosition); |
157 | fMyCount--; |
158 | fMyBunchLength--; |
159 | |
160 | return kTRUE; |
161 | } |
162 | |
163 | //_____________________________________________________________________________ |
164 | UShort_t |
165 | AliFMDRawStream::Get10BitWord(UChar_t* buffer, Int_t position) const |
166 | { |
167 | // return a word in a 10 bit array as an UShort_t |
168 | |
169 | Int_t iBit = position * 10; |
170 | Int_t iByte = iBit / 8; |
171 | Int_t shift = iBit % 8; |
172 | // return ((buffer[iByte+1] * 256 + buffer[iByte]) >> shift) & 0x03FF; |
173 | |
174 | // recalculate the byte numbers and the shift because |
175 | // the raw data is written as integers where the high bits are filled first |
176 | // -> little endian is assumed here ! |
177 | Int_t iByteHigh = 4 * (iByte / 4) + 3 - (iByte % 4); |
178 | iByte++; |
179 | Int_t iByteLow = 4 * (iByte / 4) + 3 - (iByte % 4); |
180 | shift = 6 - shift; |
181 | return ((buffer[iByteHigh] * 256 + buffer[iByteLow]) >> shift) & 0x03FF; |
182 | } |
183 | #endif |
184 | //_____________________________________________________________________________ |
185 | // |
186 | // EOF |
187 | // |