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