]>
Commit | Line | Data |
---|---|---|
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 | // | |
18 | // This is a class for reading a raw data from a root file and providing | |
19 | // information about digits | |
20 | // | |
21 | /////////////////////////////////////////////////////////////////////////////// | |
22 | ||
23 | #include "AliRawReaderRoot.h" | |
24 | ||
25 | ||
26 | ClassImp(AliRawReaderRoot) | |
27 | ||
28 | ||
29 | AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber) | |
30 | { | |
31 | // create an object to read digits from the given input file for the | |
32 | // event with the given number | |
33 | ||
34 | fFile = TFile::Open(fileName); | |
35 | if (!fFile || !fFile->IsOpen()) { | |
36 | Error("AliRawReaderRoot", "could not open file %s", fileName); | |
37 | return; | |
38 | } | |
39 | TTree* tree = (TTree*) fFile->Get("RAW"); | |
40 | if (!tree) { | |
41 | Error("AliRawReaderRoot", "no raw data tree found"); | |
42 | return; | |
43 | } | |
44 | TBranch* branch = tree->GetBranch("rawevent"); | |
45 | if (!branch) { | |
46 | Error("AliRawReaderRoot", "no raw data branch found"); | |
47 | return; | |
48 | } | |
49 | ||
50 | fEvent = new AliRawEvent; | |
51 | branch->SetAddress(&fEvent); | |
52 | if (branch->GetEntry(eventNumber) <= 0) { | |
53 | Error("AliRawReaderRoot", "no event with number %d found", eventNumber); | |
54 | return; | |
55 | } | |
56 | ||
57 | fSubEventIndex = 0; | |
58 | fSubEvent = NULL; | |
59 | fRawData = NULL; | |
60 | fMiniHeader = NULL; | |
61 | ||
62 | fCount = 0; | |
63 | fPosition = fEnd = NULL; | |
64 | } | |
65 | ||
66 | AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event) | |
67 | { | |
68 | // create an object to read digits from the given raw event | |
69 | ||
70 | fFile = NULL; | |
71 | fEvent = event; | |
72 | ||
73 | fSubEventIndex = 0; | |
74 | fSubEvent = NULL; | |
75 | fRawData = NULL; | |
76 | fMiniHeader = NULL; | |
77 | ||
78 | fCount = 0; | |
79 | fPosition = fEnd = NULL; | |
80 | } | |
81 | ||
82 | AliRawReaderRoot::~AliRawReaderRoot() | |
83 | { | |
84 | // delete objects and close root file | |
85 | ||
86 | if (fFile) { | |
87 | if (fEvent) delete fEvent; | |
88 | fFile->Close(); | |
89 | delete fFile; | |
90 | } | |
91 | } | |
92 | ||
93 | ||
94 | UInt_t AliRawReaderRoot::GetType() | |
95 | { | |
96 | // get the type from the event header | |
97 | ||
98 | if (!fEvent) return 0; | |
99 | return fEvent->GetHeader()->GetType(); | |
100 | } | |
101 | ||
102 | UInt_t AliRawReaderRoot::GetRunNumber() | |
103 | { | |
104 | // get the run number from the event header | |
105 | ||
106 | if (!fEvent) return 0; | |
107 | return fEvent->GetHeader()->GetRunNumber(); | |
108 | } | |
109 | ||
110 | const UInt_t* AliRawReaderRoot::GetEventId() | |
111 | { | |
112 | // get the event id from the event header | |
113 | ||
114 | if (!fEvent) return NULL; | |
115 | return fEvent->GetHeader()->GetId(); | |
116 | } | |
117 | ||
118 | const UInt_t* AliRawReaderRoot::GetTriggerPattern() | |
119 | { | |
120 | // get the trigger pattern from the event header | |
121 | ||
122 | if (!fEvent) return NULL; | |
123 | return fEvent->GetHeader()->GetTriggerPattern(); | |
124 | } | |
125 | ||
126 | const UInt_t* AliRawReaderRoot::GetDetectorPattern() | |
127 | { | |
128 | // get the detector pattern from the event header | |
129 | ||
130 | if (!fEvent) return NULL; | |
131 | return fEvent->GetHeader()->GetDetectorPattern(); | |
132 | } | |
133 | ||
134 | const UInt_t* AliRawReaderRoot::GetAttributes() | |
135 | { | |
136 | // get the type attributes from the event header | |
137 | ||
138 | if (!fEvent) return NULL; | |
139 | return fEvent->GetHeader()->GetTypeAttribute(); | |
140 | } | |
141 | ||
142 | UInt_t AliRawReaderRoot::GetGDCId() | |
143 | { | |
144 | // get the GDC Id from the event header | |
145 | ||
146 | if (!fEvent) return 0; | |
147 | return fEvent->GetHeader()->GetGDCId(); | |
148 | } | |
149 | ||
150 | ||
151 | Bool_t AliRawReaderRoot::ReadMiniHeader() | |
152 | { | |
153 | // read a mini header at the current position | |
154 | // returns kFALSE if the mini header could not be read | |
155 | ||
156 | if (!fEvent) return kFALSE; | |
157 | do { | |
158 | if (fCount > 0) fPosition += fCount; // skip payload if event was not selected | |
159 | if (!fSubEvent || (fPosition >= fEnd)) { // new sub event | |
160 | if (fSubEventIndex >= fEvent->GetNSubEvents()) return kFALSE; | |
161 | fSubEvent = fEvent->GetSubEvent(fSubEventIndex++); | |
162 | fRawData = fSubEvent->GetRawData(); | |
163 | fCount = 0; | |
164 | fPosition = (UChar_t*) fRawData->GetBuffer(); | |
165 | fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize(); | |
166 | } | |
167 | if (fPosition >= fEnd) continue; // no data left in the payload | |
168 | if (fPosition + sizeof(AliMiniHeader) > fEnd) { | |
169 | Error("ReadMiniHeader", "could not read data!"); | |
170 | return kFALSE; | |
171 | } | |
172 | fMiniHeader = (AliMiniHeader*) fPosition; | |
173 | fPosition += sizeof(AliMiniHeader); | |
174 | CheckMiniHeader(); | |
175 | fCount = fMiniHeader->fSize; | |
176 | if (fPosition + fCount > fEnd) { // check data size in mini header and sub event | |
177 | Error("ReadMiniHeader", "size in mini header exceeds event size!"); | |
178 | fMiniHeader->fSize = fCount = fEnd - fPosition; | |
179 | } | |
180 | } while (!IsSelected()); | |
181 | return kTRUE; | |
182 | } | |
183 | ||
184 | Bool_t AliRawReaderRoot::ReadNextData(UChar_t*& data) | |
185 | { | |
186 | // reads the next payload at the current position | |
187 | // returns kFALSE if the data could not be read | |
188 | ||
189 | while (fCount == 0) { | |
190 | if (!ReadMiniHeader()) return kFALSE; | |
191 | } | |
192 | data = fPosition; | |
193 | fPosition += fCount; | |
194 | fCount = 0; | |
195 | return kTRUE; | |
196 | } | |
197 | ||
198 | Bool_t AliRawReaderRoot::ReadNext(UChar_t* data, Int_t size) | |
199 | { | |
200 | // reads the next block of data at the current position | |
201 | // returns kFALSE if the data could not be read | |
202 | ||
203 | if (fPosition + size > fEnd) { | |
204 | Error("ReadNext", "could not read data!"); | |
205 | return kFALSE; | |
206 | } | |
207 | memcpy(data, fPosition, size); | |
208 | fPosition += size; | |
209 | fCount -= size; | |
210 | return kTRUE; | |
211 | } | |
212 | ||
213 | ||
214 | Bool_t AliRawReaderRoot::Reset() | |
215 | { | |
216 | // reset the current position to the beginning of the event | |
217 | ||
218 | fSubEventIndex = 0; | |
219 | fSubEvent = NULL; | |
220 | fRawData = NULL; | |
221 | fMiniHeader = NULL; | |
222 | ||
223 | fCount = 0; | |
224 | fPosition = fEnd = NULL; | |
225 | return kTRUE; | |
226 | } | |
227 |